relaton 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c749882e825411654761a8fa93aafe143cbcc9ff3f1ab2df213af541b423274b
-  data.tar.gz: 18424b0050827481d74048b45397610181e4b6b77f07b718bf9ab1fa589e6d6a
+  metadata.gz: f81699e1df94f1c570f01c07b4114492b7cc5ae1e45715a4ced3ef51c1ba3fb6
+  data.tar.gz: 1ea38d455d16b512807a505bd558757ea0509a9392cf41c120f3fc10801beb87
 SHA512:
-  metadata.gz: e37f88eb3fd9f0c20ae2db7bbb08fbcd54ae7b6784ab249494c39d6d56fa452940883ecb1ad5225ec27115ea6fe5a05c518ab1d143e28566a87c111d83ce2361
-  data.tar.gz: 79d5434ca258b521c473e88cd8afbd763bff52e10e46ce20ed8f3743679967bcf9cb51444eef9fd4cd21ceb11b32a830664e105eb92747378336aa91c2d63aa1
+  metadata.gz: 4d27294461f66031023053e1ec70a4c26b0c8fa068e6ed9d1224d1ab9c6cb366a2b2d8f85cd50305c4826733ab028817f70b96aebc267346d224b9be1fdf29be
+  data.tar.gz: a3c00ef5a93352f08a492624b531955494c8530a6b0d68f01dc748d58d8599304fa9ac743d157cfd2a6cc37b63664c781da75de5e199de70035ed133e70d0305

data/lib/relaton/3gpp/CLAUDE.md

@@ -154,6 +154,37 @@ guards does not depend on it. `Processor` also sets
 `@pubid_flavor = :Tgpp`, so `Core::Processor#prefixes` reads
 `Pubid::Tgpp.prefixes` (`["3GPP"]`).
 
+### Dates: published, then the Release start and end
+
+`Parser#parse_date` emits the `published` date (CSV `Date`) first, then
+`project-start` from the CSV `Project Start` column and `released` from
+`Project End` (relaton-3gpp#13). #15 defines the Release end date as the date
+the Release is released, and the issue thread asks for it as the release date
+of the specification — hence `released`, not `project-end`. Both are the dates
+of the document's **Release**, not of the document: every version in one
+Release carries the same pair, so neither fits a standard type (`issued` would
+date a 2004 `REL-98` version to 1999). They also stay in `ext/release`
+(`project_start` / `project_end`). An empty column gives no date;
+`@errors[:date]` tracks the published date only.
+
+- **`Relaton::ThreeGpp::Date`** (`date.rb`) extends `Bib::Date`'s `type`
+  value list with the two types, and `Item` shadows `date` with it (as it does
+  `docidentifier`). Without it `validate!` rejects the types; the RelaxNG
+  grammar already accepts any text. The shadow covers the top-level item
+  only: an item nested in a `relation` (the transposition) reloads as
+  `Bib::ItemBase` with plain `Bib::Date`s. Nothing validates those today.
+- **The constant hides Ruby's `::Date`** inside `Relaton::ThreeGpp`. Write
+  `::Date.parse` / `::Date.today` in this flavor; a bare `Date.today` now
+  raises `NoMethodError`.
+- **Select the publication date by type, never by `date[0]`.**
+  `DataFetcher#published_date` does this for the transposition check: a row
+  with no `Date` still has the two Release dates, so `date.any?` no longer
+  means "has a publication date".
+- `spec/3gpp/fixtures/bib.xml`, `bibdata.xml` and `bib.yaml` are rendered from
+  the `3gpp_get_document` cassette, i.e. from the published
+  `relaton-data-3gpp` record. They get the two dates only after that repo
+  re-crawls and the cassette is re-recorded — do not hand-add them.
+
 ## Testing
 
 - `bundle exec rake spec:3gpp` — run the 3GPP suite.

data/lib/relaton/3gpp/bibliography.rb

@@ -25,7 +25,7 @@ module Relaton
         return unless resp.code == "200"
 
         item = Item.from_yaml(resp.body)
-        item.fetched = Date.today.to_s
+        item.fetched = ::Date.today.to_s
         item
       rescue  SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
               EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,

data/lib/relaton/3gpp/data_fetcher.rb

@@ -42,7 +42,14 @@ module Relaton
           index.remove_all # if renewal
         end
         CSV.open(file, "r:bom|utf-8", headers: true, col_sep: ";").each do |row|
-          save_doc Parser.parse(row, @errors)
+          # The row carries the whole record payload, so an unchanged row
+          # skips the parse and the write (the digest ledger). The row is
+          # only read when the ledger is on.
+          key = @digest_ledger ? "#{row[0]}/#{row['Version']}" : nil
+          next if key && unchanged?(key, row.to_h)
+
+          file = save_doc Parser.parse(row, @errors)
+          note_digest key, row.to_h, file: file if key
         end
         File.write CURRENT, @current.to_yaml, encoding: "UTF-8"
         index.save
@@ -132,7 +139,11 @@ module Relaton
           @files << file
           index_primary bib1.docidentifier&.detect(&:primary), file
         end
-        File.write file, serialize(bib1), encoding: "UTF-8" unless bib1.nil?
+        return nil if bib1.nil?
+
+        File.write file, serialize(bib1), encoding: "UTF-8"
+        record_written file
+        file
       end
 
       #
@@ -210,11 +221,9 @@ module Relaton
       # @return [Array<Relaton3gpp::BibliographicItem, Boolean>] main bibliographic item,
       #   related bibliographic item, true if relation has been added
       #
-      def transposed_relation(bib, existed) # rubocop:disable Metrics/CyclomaticComplexity
-        if (bib.date.none? && existed.date.none?) || (bib.date.any? && existed.date.none?)
-          return [bib, existed, false]
-        end
-        return [existed, bib, true] if bib.date.none? && existed.date.any?
+      def transposed_relation(bib, existed)
+        return [bib, existed, false] unless published_date(existed)
+        return [existed, bib, true] unless published_date(bib)
 
         check_transposed_date bib, existed
       end
@@ -229,16 +238,30 @@ module Relaton
       #   related bibliographic item, true if relation has been added
       #
       def check_transposed_date(bib, existed)
-        if bib.date[0].at < existed.date[0].at
+        bib_date = published_date(bib).at
+        existed_date = published_date(existed).at
+        if bib_date < existed_date
           add_transposed_relation bib, existed
           [bib, existed, true]
-        elsif bib.date[0].at > existed.date[0].at
+        elsif bib_date > existed_date
           add_transposed_relation existed, bib
           [existed, bib, true]
         else [bib, existed, false]
         end
       end
 
+      #
+      # The publication date. The date array also holds the Release start and
+      # end, which say nothing about which version came first.
+      #
+      # @param [Relaton::ThreeGpp::ItemData] bib bibliographic item
+      #
+      # @return [Relaton::ThreeGpp::Date, nil]
+      #
+      def published_date(bib)
+        bib.date.detect { |d| d.type == "published" }
+      end
+
       #
       # Add transposed relation
       #

data/lib/relaton/3gpp/date.rb

@@ -0,0 +1,13 @@
+module Relaton
+  module ThreeGpp
+    # A bibliographic date that also accepts the start of the document's 3GPP
+    # Release (`project-start`) and its end, which is the release date of the
+    # Release (`released`, relaton-3gpp#13). The RelaxNG grammar takes any text
+    # as a date type; only the Bib::Date value list needs the two extra types.
+    class Date < Bib::Date
+      RELEASE_TYPES = %w[project-start released].freeze
+
+      attribute :type, :string, values: Bib::Date.attributes[:type].options[:values] + RELEASE_TYPES
+    end
+  end
+end

data/lib/relaton/3gpp/item.rb

@@ -1,6 +1,7 @@
 require_relative "item_data"
 require_relative "ext"
 require_relative "docidentifier"
+require_relative "date"
 
 module Relaton
   module ThreeGpp
@@ -13,6 +14,8 @@ module Relaton
       # Item, so this one declaration covers all three.
       attribute :docidentifier, Docidentifier, collection: true,
                                                initialize_empty: true
+      # Same shadow for the dates, which carry the Release start and end.
+      attribute :date, Date, collection: true, initialize_empty: true
     end
   end
 end

data/lib/relaton/3gpp/parser.rb

@@ -143,17 +143,20 @@ module Relaton
       # end
 
       #
-      # Parse date
+      # Parse date. The published date comes first, then the start of the
+      # document's Release and its end as the release date (relaton-3gpp#13).
       #
-      # @return [Array<RelatonBib::BibliographicDate>] date
+      # @return [Array<Relaton::ThreeGpp::Date>] date
       #
       def parse_date
         dates = []
         if @row["Date"]
-          on = Date.parse(@row["Date"]).to_s
-          dates << Bib::Date.new(type: "published", at: on)
+          on = ::Date.parse(@row["Date"]).to_s
+          dates << Date.new(type: "published", at: on)
         end
         @errors[:date] &&= dates.empty?
+        dates << Date.new(type: "project-start", at: project_start.to_s) if project_start
+        dates << Date.new(type: "released", at: project_end.to_s) if project_end
         dates
       end
 
@@ -388,12 +391,12 @@ module Relaton
 
       def project_start
         @errors[:project_start] &&= @row["Project Start"].nil? || @row["Project Start"].empty?
-        Date.parse(@row["Project Start"]) if @row["Project Start"]
+        ::Date.parse(@row["Project Start"]) if @row["Project Start"]
       end
 
       def project_end
         @errors[:project_end] &&= @row["Project End"].nil? || @row["Project End"].empty?
-        Date.parse(@row["Project End"]) if @row["Project End"]
+        ::Date.parse(@row["Project End"]) if @row["Project End"]
       end
     end
   end

data/lib/relaton/bib/model/item_shared.rb

@@ -59,10 +59,21 @@ module Relaton
       def self.prune_attribute(base, attr_name, xml_name)
         return unless base.attributes.key?(attr_name)
 
+        # lutaml-model 0.8.142 shares a subclass's mappings/attributes with
+        # its superclass until the class's own DSL forks them (copy-on-write).
+        # These deletes must stay private to `base`: without the fork, pruning
+        # Bibdata's :id erased it from Bibitem (and Bibitem's :ext from
+        # Bibdata), and every from_xml raised "Attribute ... not found".
+        # 0.8.141 and older give each class private copies and have no
+        # lutaml_cow_fork!, where mutating in place was already safe.
+        if base.respond_to?(:lutaml_cow_fork!)
+          base.lutaml_cow_fork!(:mappings)
+          base.lutaml_cow_fork!(:attributes)
+        end
         xml_mapping = base.mappings[:xml]
         xml_mapping.instance_variable_get(:@elements).delete(xml_name)
         xml_mapping.instance_variable_get(:@attributes).delete(xml_name)
-        base.attributes.delete(attr_name)
+        base.class_attributes.delete(attr_name)
       end
 
       XML_BODY = lambda do # rubocop:disable Metrics/BlockLength

data/lib/relaton/calconnect/data_fetcher.rb

@@ -70,8 +70,14 @@ module Relaton::Calconnect
     # @param [Hash] doc
     #
     def parse_page(doc)
+      # The document payload carries the whole record, so an unchanged
+      # payload skips the scrape and the write (the digest ledger). The
+      # payload is only read when the ledger is on.
+      return true if @digest_ledger && unchanged?(doc["id"], doc)
+
       bib = Scraper.new(@errors).parse_page doc
-      write_doc doc["id"], bib
+      file = write_doc doc["id"], bib
+      note_digest doc["id"], doc, file: file if @digest_ledger
       true
     rescue StandardError => e
       Util.warn "Document: #{doc['id']}"
@@ -95,7 +101,9 @@ module Relaton::Calconnect
       # Write first, index second: an id pubid rejects is skipped from the
       # index, and the document still has to reach disk.
       File.write file, serialize(bib), encoding: "UTF-8"
+      record_written file
       add_to_index bib, file
+      file
     end
 
     #

data/lib/relaton/cie/authors_parser.rb

@@ -0,0 +1,78 @@
+module Relaton
+  module Cie
+    # CIE publishes its author lists as one inconsistently formatted string:
+    # "Surname, I.X." pairs, bare "Forename Surname" runs, Chinese-style
+    # "Surname Given" without a comma, compound surnames ("Nilsson
+    # Tengelin"), broken hyphens ("Dam- Hansen"), " and " before the final
+    # author, and "et al." tails (relaton-cie#5). The comma is overloaded --
+    # it separates authors and marks the surname/forename boundary -- so the
+    # parse walks comma-separated segments with three rules:
+    #
+    # 1. a single-word segment binds the following segment as its forenames
+    #    ("Hemphälä, Hillevi"; initials "A.Sh." bind the same way);
+    # 2. a multi-word segment followed by an initials-only segment binds
+    #    them ("Nilsson Tengelin, M."), because initials never stand alone;
+    # 3. any other segment is one author kept whole (completename) --
+    #    "Glimne Susanne", "Annika K. Jägerbrand", "Pan Jiangen": which word
+    #    is the surname would be a guess, so none is made.
+    module AuthorsParser
+      Author = Struct.new(:surname, :forenames, :completename)
+
+      # Uppercase-led, dot/hyphen/space-separated short parts only:
+      # "A.Sh.", "H.T.B", "W-T. M.", "N." -- never "Li" (lowercase tail),
+      # "Guillaume" (long undotted part) or "Bierman".
+      INITIALS_RX = /\A\p{Lu}(?:[.\s-]+\p{Lu}\p{Ll}{0,2})*\.?\z/.freeze
+
+      class << self
+        # @param string [String] the CIE authors string
+        # @return [Array<Author>]
+        def parse(string)
+          authors = []
+          segments = segmentize(string)
+          i = 0
+          while i < segments.length
+            seg = segments[i]
+            nxt = segments[i + 1]
+            i += if initials?(seg)
+                   # Defensive: a stray initials segment binds left.
+                   authors.last&.forenames << seg
+                   1
+                 elsif single_word?(seg) || nxt && initials?(nxt)
+                   # "Surname, Forename": a single-word segment binds
+                   # whatever follows; a multi-word one only binds trailing
+                   # initials, which never stand alone.
+                   authors << Author.new(seg, nxt ? [nxt] : [], nil)
+                   nxt ? 2 : 1
+                 else
+                   authors << Author.new(nil, nil, seg)
+                   1
+                 end
+          end
+          authors
+        end
+
+        # @param seg [String]
+        # @return [Boolean]
+        def single_word?(seg)
+          !seg.include?(" ")
+        end
+
+        # @param seg [String]
+        # @return [Boolean]
+        def initials?(seg)
+          INITIALS_RX.match? seg
+        end
+
+        private
+
+        def segmentize(string)
+          string
+            .gsub(/(\p{L})- (?=\p{Lu})/, '\1-')
+            .gsub(%r{\s*,?\s+and\s+}i, ", ")
+            .sub(/\s*,?\s*et\s+al\.?\s*\z/i, "")
+            .split(/\s*[,;]\s*/).map(&:strip).reject(&:empty?)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/cie/data_fetcher.rb

@@ -329,28 +329,21 @@ module Relaton
       def fetch_contributor(doc) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity
         authors = doc.xpath('//hgroup/p[not(@class="pub_date")]').text.gsub "\"", ""
         contribs = []
-        until authors.empty?
-          /^(?<sname1>\S+(?:\sder?\s)?[^\s,]+)
-          (?:,?\s(?<sname2>[\w-]{2,})(?=,\s+\w\.))?
-          (?:,?\s(?<fname>W-T\.[\w-]{2,})(?!,\s+\w\.))?
-          (?:(?:\s?,\s?|\s)(?<init>(?:\w(?:\s?\.|\s|,|$)[\s-]?)+))?
-          (?:(?:[,;]\s*|\s+|\.|(?<=\s))(?:and\s)?)?/x =~ authors
-          raise StandardError, "Author name not found in \"#{authors}\"" unless $LAST_MATCH_INFO
-
-          authors.sub! $LAST_MATCH_INFO.to_s, ""
-          sname = [sname1, sname2].compact.join " "
-          surname = Bib::LocalizedString.new content: sname, language: "en", script: "Latn"
-          forename = []
-          forename << Bib::FullNameType::Forename.new(content: fname, language: "en", script: "Latn") if fname
-          (init&.strip || "").split(/(?:,|\.)(?:-|\s)?/).each do |int|
-            forename << Bib::FullNameType::Forename.new(content: "", initial: int.strip, language: "en", script: "Latn")
-          end
-          fullname = Bib::FullName.new surname: surname, forename: forename
+        AuthorsParser.parse(authors).each do |author|
+          fullname =
+            if author.completename
+              Bib::FullName.new completename: name_string(author.completename)
+            else
+              Bib::FullName.new(
+                surname: name_string(author.surname),
+                forename: author.forenames.map { |f| forename(f) },
+              )
+            end
           person = Bib::Person.new name: fullname
           role = Bib::Contributor::Role.new type: "author"
           contribs << Bib::Contributor.new(person: person, role: [role])
-          @errors[:contributor_author] &&= contribs.empty?
         end
+        @errors[:contributor_author] &&= contribs.empty?
         org_name = Bib::TypedLocalizedString.new(content: "Commission Internationale de L'Eclairage")
         abbrev = Bib::LocalizedString.new content: "CIE"
         org_uri = Bib::Uri.new content: "cie.co.at"
@@ -359,6 +352,18 @@ module Relaton
         contribs << Bib::Contributor.new(organization: org, role: [org_role])
       end
 
+      def name_string(str)
+        Bib::LocalizedString.new content: str, language: "en", script: "Latn"
+      end
+
+      def forename(str)
+        if AuthorsParser.initials?(str)
+          Bib::FullNameType::Forename.new(initial: str.sub(/\.\z/, ""))
+        else
+          Bib::FullNameType::Forename.new(content: str)
+        end
+      end
+
       def fetch_ext
         Ext.new(doctype: fetch_doctype, flavor: "cie")
       end

data/lib/relaton/cie.rb

@@ -5,6 +5,7 @@ require "relaton/index"
 require "relaton/bib"
 # require "relaton_bib/name_parser"
 require_relative "version"
+require_relative "cie/authors_parser"
 require_relative "cie/util"
 require_relative "cie/item_data"
 require_relative "cie/item"

data/lib/relaton/core/data_fetcher.rb

@@ -36,6 +36,17 @@ module Relaton
       # @return [Boolean] whether this run prunes the existing output tree
       attr_accessor :prune
 
+      # Record a file this run wrote through a flavor's own writer, so the
+      # ledger's save (which keeps only files this run owned) and
+      # #prune_unwritten account for it. Core's write_unique records its
+      # own writes; a flavor writing directly calls this after File.write.
+      #
+      # @param file [String]
+      # @return [void]
+      def record_written(file)
+        @written << file
+      end
+
       # @return [Boolean] whether this run consults and maintains the
       #   content-digest ledger (see #unchanged?). Off by default: a flavor
       #   turns it on only where its enumeration entry determines the record
@@ -91,6 +102,16 @@ module Relaton
         ledger_new[key] = { "digest" => entry_digest(entry), "file" => file }
       end
 
+      # The file a previous run recorded for `key`, for a caller that
+      # skipped the record via #unchanged? and still needs to know where it
+      # lives (an alias pointing at another record's file).
+      #
+      # @param key [String]
+      # @return [String, nil]
+      def ledger_file(key)
+        ledger.dig(key, "file")
+      end
+
       # Persist the ledger: this run's noted entries over the loaded ones,
       # keeping only entries whose file this run recorded as written.
       #

data/lib/relaton/iana/data_fetcher.rb

@@ -13,12 +13,14 @@ module Relaton
       end
 
       def fetch(_source = nil)
+        docs = []
         Dir["iana-registries/**/*.xml"].each do |file|
           content = File.read file, encoding: "UTF-8"
-          parse(content) if content.include? "<registry"
+          collect content, docs if content.include? "<registry"
         rescue StandardError => e
           Util.error "Error: #{e.message}. File: #{file}"
         end
+        write_docs docs
         index.save
         report_errors
       end
@@ -50,12 +52,57 @@ module Relaton
         Util.warn "Skipping index entry for `#{docnumber}` (#{file}): #{e.message}"
       end
 
-      def parse(content)
+      # A registry element with no <record> children carries no registry data
+      # of its own: IANA wraps some registries in a same-titled <hide/> page
+      # (the language-tag-extensions wrapper around its "-1" child), and
+      # republishes child registries as standalone pages whose XML is empty
+      # (rpki-signed-objects). The saved record for such an element is a
+      # slug-titled, dateless duplicate of the registry that holds the
+      # records (relaton-iana#8, #9), so it never becomes a document: when a
+      # record-bearing document of the same registry id exists, it becomes an
+      # index alias to that document's file; otherwise it is dropped.
+      RegistryDoc = Struct.new(:bib, :empty, :source)
+
+      def collect(content, docs)
         xml = Moxml.parse(content)
         registry = xml.at_xpath("/xmlns:registry", NS)
         doc = Parser.parse registry, nil, @errors
-        save_doc doc
-        registry.xpath("./xmlns:registry", NS).each { |r| save_doc Parser.parse(r, doc, @errors) }
+        docs << RegistryDoc.new(doc, recordless?(registry), content) if doc
+        registry.xpath("./xmlns:registry", NS).each do |r|
+          child = Parser.parse r, doc, @errors
+          docs << RegistryDoc.new(child, recordless?(r), content) if child
+        end
+      end
+
+      def recordless?(registry_el)
+        registry_el.xpath("./xmlns:record", NS).empty?
+      end
+
+      def write_docs(docs)
+        saved = {}
+        docs.each do |d|
+          if d.empty
+            Util.warn "Registry #{d.bib.docnumber} has no records; skipping"
+            next
+          end
+          # The fetched XML content bounds the registry's record, so an
+          # unchanged source skips the parse and the write (the digest
+          # ledger); the aliased file still has to resolve for the alias
+          # phase. The content is only digested when the ledger is on.
+          if @digest_ledger && d.source && unchanged?(d.bib.docnumber, d.source)
+            saved[d.bib.id] = ledger_file(d.bib.docnumber)
+            next
+          end
+          file = save_doc d.bib
+          note_digest d.bib.docnumber, d.source, file: file if @digest_ledger && d.source
+          saved[d.bib.id] = file if file
+        end
+        docs.select(&:empty).each do |d|
+          next unless (file = saved[d.bib.id])
+
+          Util.warn "Registry #{d.bib.docnumber} has no records; aliasing #{file}"
+          add_to_index d.bib.docnumber, file
+        end
       end
 
       #
@@ -83,6 +130,8 @@ module Relaton
         @files << file
         add_to_index bib.docnumber, file
         File.write file, serialize(bib), encoding: "UTF-8"
+        record_written file
+        file
       end
 
       def to_xml(bib)

data/lib/relaton/ieee/CLAUDE.md

@@ -24,10 +24,36 @@ serialized to the `_type: pubid:ieee:*` (lutaml) form, keyed on the index via
   loss is never silent. `DataFetcher.fetch` (doc generation) is unchanged — the
   data repo (`relaton-data-ieee`) calls `build_index` after obtaining `data/`.
 - **Read side.** `bibliography.rb#search` passes `pubid_class:` to `find_or_create`,
-  parses the query with `parse_pubid` (falling back to the raw String on failure),
-  passes the pubid to `index.search` for number-narrowing, and picks the row by
-  `row[:id].to_s`. `processor.rb#remove_index_file` passes `url: true` and `file:`
-  only: the delete never reads the index (see `lib/relaton/index/CLAUDE.md`).
+  parses the query with `parse_pubid` (falling back to the raw String on failure)
+  and passes the pubid to `index.search` for number-narrowing. A parsed query
+  selects its rows by **pubid equality with the year aside**
+  (`id.exclude(:year) == pubid.exclude(:year)`), so a redline, a draft, a
+  corrigendum and another number (`1003.10` for `1003.1`) never match. A dated
+  query (its own year, or the `year` argument) takes that year; an **undated**
+  query takes the **latest** edition, and `get` returns it as
+  `to_most_recent_reference` (undated IEEE docids, no date, an `instanceOf`
+  relation to the edition; `opts[:keep_year]` keeps it dated) — relaton-ieee#29.
+  Before this, a substring match + `min_by(to_s)` answered `IEEE 528` with the
+  oldest edition, `528-1994`. When equality finds nothing (an unparseable query,
+  or one of the ~4% of forms whose year pubid keeps elsewhere, e.g.
+  `IEEE Std 1003.1-1988/INT-1992`, the corrigendum's legacy base year), the old
+  substring match is the fallback. `processor.rb#remove_index_file` passes
+  `url: true` and `file:` only: the delete never reads the index (see
+  `lib/relaton/index/CLAUDE.md`).
+- **Why not `pubid === row`.** pubid declares no `subset_strict` attribute for
+  IEEE, so a nil `parts`, `prefix`, `draft` or `draft_status` in the query is a
+  wildcard: over the published index (12,616 rows) `===` let `IEEE 802.3` match
+  `802.3.1-2011` and `IEEE 754` match `IEEE Unapproved P754/D9.0`. Switch to
+  `index.search(pubid)` once pubid makes those strict, and re-measure `===`
+  against the equality over the full index first.
+- **`Relaton::Ieee::Docidentifier`.** `Item` holds this class (the producer
+  creates it too: `IdamsParser#docidentifier`, `DataFetcher`), because
+  `Bib::Docidentifier#remove_date!` is a no-op. Its `remove_date!` re-renders an
+  `IEEE` docid through pubid without the year (`to_s(trademark: true)` for the
+  `scope: trademark` one) and leaves an id **with no year** untouched: a
+  re-render would change a draft's spelling (`P802.5t™/D-2.5` →
+  `P802.5t®/D2.5`). `ItemData#to_most_recent_reference` drops the ISBN and
+  DOI, which name one edition.
 
 ## Identifier resolution (`RawbibIdParser`, pubid-first)
 

data/lib/relaton/ieee/bibliography.rb

@@ -9,33 +9,12 @@ module Relaton
         #
         # @param ref [String, Pubid::Ieee::Identifier] the reference, or its
         #   parse from Relaton::Db (relaton#205)
+        # @param year [String, nil] the year, when the reference has none
         #
         # @return [Relaton::Ieee::ItemData, nil]
         #
-        def search(ref) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          # The machine index on the Pages site (relaton#206, the W3C
-          # pilot's contract): a parsed query reads only its own shard. A
-          # Pages failure raises `Relaton::RequestError`; the whole-index
-          # zip on the same site serves only the retry on a miss.
-          index = Relaton::Index.find_or_create :ieee, pages_url: PAGES_URL,
-                                                       pubid_class: ::Pubid::Ieee::Identifier
-          # Pass the parsed pubid (not the raw String) so index-v2 narrows
-          # candidates by number via binary search before the block runs; the
-          # block keeps the broad substring match the string index gave, and an
-          # unparseable/partial ref falls back to the full-scan String search.
-          # Rows are Pubid::Ieee::Identifier objects (not Comparable), so pick by
-          # the string form.
-          pubid = parse_pubid ref
-          needle = pubid.to_s
-          # pubid's normalization moves a legacy base year into its own
-          # comma segment ("IEEE P802.16/D5, 2004/Cor. 1-2005"); the
-          # index rows carry the canonical form without it, so the
-          # block also matches with the moved year stripped
-          row = index.search(pubid) do |r|
-            id = r[:id].to_s
-            id.include?(needle) ||
-              id.include?(needle.gsub(/, (19|20)\d{2}\//, "/"))
-          end.min_by { |r| r[:id].to_s }
+        def search(ref, year = nil)
+          row = find_row parse_pubid(ref), year
           return unless row
 
           resp = Faraday.get "#{GH_URL}#{row[:file]}"
@@ -47,30 +26,106 @@ module Relaton
         end
 
         #
-        # Get IEEE bibliography item by reference.
+        # Get IEEE bibliography item by reference. An undated reference
+        # answers with the latest edition as an undated item that has an
+        # `instanceOf` relation to that edition (relaton-ieee#29).
         #
         # @param ref [String, Pubid::Ieee::Identifier] the IEEE standard
         #   reference to look up (e.g. "IEEE 528-2019"), or its parse from
         #   Relaton::Db (relaton#205)
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options
+        # @option opts [Boolean] :keep_year keep the edition's date on an
+        #   undated reference
         #
         # @return [Relaton::Ieee::ItemData, nil]
         #
-        def get(ref, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           Util.info "Fetching from Relaton repository ...", key: ref.to_s
-          item = search(ref)
-          if item
-            Util.info "Found: `#{item.docidentifier.first.content}`", key: ref.to_s
-            item
-          else
+          item = search(ref, year)
+          unless item
             Util.info "Not found.", key: ref.to_s
-            nil
+            return
           end
+
+          Util.info "Found: `#{item.docidentifier.first.content}`", key: ref.to_s
+          return item if opts[:keep_year] || dated?(parse_pubid(ref), year)
+
+          item.to_most_recent_reference
         end
 
         private
 
+        # The index row of the reference. A parsed reference matches the rows
+        # of its own document by pubid equality, the year aside; an undated
+        # one takes the latest edition. When that finds nothing (an
+        # unparseable reference, or a form whose year pubid keeps elsewhere)
+        # the broad substring match is the fallback.
+        #
+        # @param pubid [Pubid::Ieee::Identifier, String]
+        # @param year [String, nil]
+        # @return [Hash, nil] the `{ id:, file: }` row
+        def find_row(pubid, year)
+          index = Relaton::Index.find_or_create :ieee, pages_url: PAGES_URL,
+                                                       pubid_class: ::Pubid::Ieee::Identifier
+          row = pubid_row(index, pubid, year) unless pubid.is_a?(String)
+          row || substring_row(index, pubid)
+        end
+
+        # Not `pubid === row`: IEEE `parts`, `prefix`, `draft` and
+        # `draft_status` are not `subset_strict` in pubid, so a nil there is a
+        # wildcard and `IEEE 802.3` would match `IEEE Std 802.3.1-2011` and
+        # `IEEE Unapproved P802.3/D2.0`.
+        def pubid_row(index, pubid, year)
+          target = (pubid.year || year)&.to_s
+          base = pubid.exclude(:year)
+          rows = index.search(pubid) do |r|
+            id = r[:id]
+            id.is_a?(::Pubid::Ieee::Identifier) && id.exclude(:year) == base &&
+              (target.nil? || id.year.to_s == target)
+          end
+          return rows.min_by { |r| r[:id].to_s } if target
+
+          rows.max_by { |r| [r[:id].year.to_s, r[:id].to_s] }
+        end
+
+        # pubid's normalization moves a legacy base year into its own comma
+        # segment ("IEEE P802.16/D5, 2004/Cor. 1-2005"); the index rows carry
+        # the canonical form without it, so the block also matches with the
+        # moved year stripped. Rows are Pubid::Ieee::Identifier objects (not
+        # Comparable), so pick by the string form.
+        #
+        # The project prefix moves too: "IEEE P802.21/D14" parses as a
+        # ProjectDraft, but the pre-publication crawl records spell the same
+        # document "IEEE Unapproved 802.21/D14, Sept 2008" — the Unapproved
+        # draft status occupies the slot the publisher and P would render in,
+        # so the row string contains neither (relaton-ieee#25). The draft
+        # number "/D14" still has to match, so the bare form cannot reach the
+        # published standard or a different draft — the variant exists only
+        # for a reference that names its draft.
+        def substring_row(index, pubid)
+          needle = pubid.to_s
+          # The publisher-and-prefix-stripped form; nil when there is no
+          # project-prefixed draft number.
+          stripped = needle.sub("IEEE P", "") if needle.match?(/\AIEEE P\S*\/D\d/i)
+          index.search(pubid) do |r|
+            id = r[:id].to_s
+            id.include?(needle) ||
+              id.include?(needle.gsub(/, (19|20)\d{2}\//, "/")) ||
+              (stripped && id.include?(stripped))
+          end.min_by { |r| r[:id].to_s }
+        end
+
+        # @param pubid [Pubid::Ieee::Identifier, String]
+        # @param year [String, nil]
+        def dated?(pubid, year)
+          return true if year
+          return pubid.year if pubid.respond_to?(:year)
+
+          # An unparseable reference was found by substring; leave it dated.
+          true
+        end
+
         # Parse a reference into a Pubid::Ieee::Identifier for index narrowing, or
         # return the raw String when pubid can't parse it (e.g. a partial ref) so
         # the search falls back to the substring scan.

data/lib/relaton/ieee/data_fetcher.rb

@@ -171,7 +171,7 @@ module Relaton
         end
         return if RELATION_TYPES[type] == false
 
-        docid = Bib::Docidentifier.new(type: "IEEE", content: fref, primary: true)
+        docid = Docidentifier.new(type: "IEEE", content: fref, primary: true)
         bib = ItemData.new formattedref: Bib::Formattedref.new(content: fref), docidentifier: [docid]
         description = create_relation_description type
         Bib::Relation.new(type: RELATION_TYPES[type][:type], description: description, bibitem: bib)

data/lib/relaton/ieee/docidentifier.rb

@@ -0,0 +1,37 @@
+module Relaton
+  module Ieee
+    # IEEE document identifier. An `IEEE` docid is backed by a
+    # Pubid::Ieee::Identifier so `remove_date!` can strip the year when an
+    # undated reference answers with its latest edition (relaton-ieee#29).
+    # ISBN and DOI docids carry no pubid and are never changed.
+    class Docidentifier < Bib::Docidentifier
+      # Strip the year: `IEEE Std 528-2019` -> `IEEE Std 528`, and the
+      # trademark docid `IEEE Std 528™-2019` -> `IEEE Std 528™`. An id with no
+      # year is left as it is: a re-render would change its spelling
+      # (`IEEE P802.5t™/D-2.5` -> `IEEE P802.5t®/D2.5`).
+      def remove_date!
+        pubid = parse_pubid
+        return unless pubid&.year
+
+        undated = pubid.exclude(:year)
+        self.content = scope == "trademark" ? undated.to_s(trademark: true) : undated.to_s
+      end
+
+      # IEEE has no all-parts form: both are no-ops, so
+      # `Bib::ItemData#to_all_parts` never raises.
+      def remove_part!; end
+
+      def to_all_parts!; end
+
+      private
+
+      def parse_pubid
+        return unless type == "IEEE" && content
+
+        ::Pubid::Ieee::Identifier.parse content
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/relaton/ieee/idams_parser.rb

@@ -92,7 +92,7 @@ module Relaton
       #
       # Parse identifiers
       #
-      # @return [Array<Relaton::Bib::Docidentifier>]
+      # @return [Array<Relaton::Ieee::Docidentifier>]
       #
       def parse_docidentifier # rubocop:disable Metrics/MethodLength
         ids = @doc.isbn_doi.map { |id| id[:content] = id.delete(:id); id }
@@ -102,7 +102,7 @@ module Relaton
           ids.unshift(content: pubid.to_s, type: "IEEE", primary: true)
         end
 
-        result = ids.map { |dcid| Bib::Docidentifier.new(**dcid) }
+        result = ids.map { |dcid| Docidentifier.new(**dcid) }
         @errors[:docidentifier] &&= result.empty?
         result
       end

data/lib/relaton/ieee/item.rb

@@ -1,4 +1,5 @@
 require_relative "ext"
+require_relative "docidentifier"
 
 module Relaton
   module Ieee
@@ -6,6 +7,8 @@ module Relaton
       model ItemData
 
       attribute :ext, Ext
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
     end
   end
 end

data/lib/relaton/ieee/item_data.rb

@@ -1,7 +1,13 @@
 module Relaton
   module Ieee
     class ItemData < Bib::ItemData
-
+      # The ISBN and DOI name one edition, so the undated item keeps only the
+      # IEEE docids; its `instanceOf` relation still carries them.
+      def to_most_recent_reference
+        me = super
+        me.docidentifier = me.docidentifier.select { |d| d.type == "IEEE" }
+        me
+      end
     end
   end
 end

data/lib/relaton/jis/hit_collection.rb

@@ -95,8 +95,7 @@ module Relaton
       def index
         @index ||= Relaton::Index.find_or_create(
           :jis,
-          url: "#{GH_URL}#{INDEXFILE}.zip",
-          file: "#{INDEXFILE}.yaml",
+          pages_url: PAGES_URL,
           pubid_class: ::Pubid::Jis::Identifier,
         )
       end

data/lib/relaton/jis.rb

@@ -17,6 +17,7 @@ module Relaton
   module Jis
     # The pubid index. relaton-data-jis rebuilds the legacy index-v1 from data/.
     INDEXFILE = "index-v2"
+    PAGES_URL = "https://relaton.github.io/relaton-data-jis/"
 
     class Error < StandardError; end
 

data/lib/relaton/nist/hit_collection.rb

@@ -356,7 +356,7 @@ module Relaton
         end
 
         index = Relaton::Index.find_or_create(
-          :nist, url: "#{GHNISTDATA}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          :nist, pages_url: PAGES_URL,
           pubid_class: ::Pubid::Nist::Identifier
         )
         # search(r) narrows candidates by number via binary search; the block

data/lib/relaton/nist.rb

@@ -22,6 +22,7 @@ module Relaton
     # (for older gem versions) is rebuilt separately by the relaton-data-nist
     # crawler, not by this gem's DataFetcher.
     INDEXFILE = "index-v2"
+    PAGES_URL = "https://relaton.github.io/relaton-data-nist/"
 
     class Error < StandardError; end
 

data/lib/relaton/plateau/hit_collection.rb

@@ -30,7 +30,7 @@ module Relaton
 
       def index
         @index ||= Relaton::Index.find_or_create(
-          :plateau, url: "#{ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          :plateau, pages_url: PAGES_URL,
           pubid_class: ::Pubid::Plateau::Identifier
         )
       end

data/lib/relaton/plateau.rb

@@ -19,6 +19,7 @@ require_relative "plateau/processor"
 module Relaton
   module Plateau
     INDEXFILE = "index-v2"
+    PAGES_URL = "https://relaton.github.io/relaton-data-plateau/"
 
     class Error < StandardError; end
 

data/lib/relaton/version.rb

@@ -1,3 +1,3 @@
 module Relaton
-  VERSION = "3.0.0".freeze
+  VERSION = "3.0.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -422,6 +422,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.26'
+- !ruby/object:Gem::Dependency
+  name: parsanol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.112
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.112
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -556,6 +576,7 @@ files:
 - lib/relaton/3gpp/bibitem.rb
 - lib/relaton/3gpp/bibliography.rb
 - lib/relaton/3gpp/data_fetcher.rb
+- lib/relaton/3gpp/date.rb
 - lib/relaton/3gpp/docidentifier.rb
 - lib/relaton/3gpp/doctype.rb
 - lib/relaton/3gpp/ext.rb
@@ -749,6 +770,7 @@ files:
 - lib/relaton/cie.rb
 - lib/relaton/cie/CLAUDE.md
 - lib/relaton/cie/README.adoc
+- lib/relaton/cie/authors_parser.rb
 - lib/relaton/cie/bibdata.rb
 - lib/relaton/cie/bibitem.rb
 - lib/relaton/cie/bibliography.rb
@@ -953,6 +975,7 @@ files:
 - lib/relaton/ieee/converter/bibxml/from_rfcxml.rb
 - lib/relaton/ieee/converter/bibxml/from_rfcxml_referencegroup.rb
 - lib/relaton/ieee/data_fetcher.rb
+- lib/relaton/ieee/docidentifier.rb
 - lib/relaton/ieee/doctype.rb
 - lib/relaton/ieee/editorial_group.rb
 - lib/relaton/ieee/ext.rb