relaton 3.0.0 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c749882e825411654761a8fa93aafe143cbcc9ff3f1ab2df213af541b423274b
-  data.tar.gz: 18424b0050827481d74048b45397610181e4b6b77f07b718bf9ab1fa589e6d6a
+  metadata.gz: f15745a534625b27b3d013d7b3d6edd7e0185f1bcc1c545f7b44dc6059d9d113
+  data.tar.gz: ac15b5259abb3c980cd6bee9d10c5f2f0ae12fea955478ca28f7da82027ab6f6
 SHA512:
-  metadata.gz: e37f88eb3fd9f0c20ae2db7bbb08fbcd54ae7b6784ab249494c39d6d56fa452940883ecb1ad5225ec27115ea6fe5a05c518ab1d143e28566a87c111d83ce2361
-  data.tar.gz: 79d5434ca258b521c473e88cd8afbd763bff52e10e46ce20ed8f3743679967bcf9cb51444eef9fd4cd21ceb11b32a830664e105eb92747378336aa91c2d63aa1
+  metadata.gz: de3f2c7182f6a2b1737a54e9168bcab856dbc81fe169f293b5b932f0224e8cb95187f506829230068ebc5308884e89a918515b03838f969c9c9870020442efff
+  data.tar.gz: a4bfe1d14667d8907eecd43fe880b02e7d15ceab20d2c6302c8f5c220d6c4398b3adefa056ff8815639686ad85674713c5c3a4759bd5ad57ffdd1e42b9bc39e1

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/converter/csl.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "json"
+require "yeptris"
+
 
 module Relaton
   module Bib
@@ -43,7 +44,7 @@ module Relaton
             keywords = Array(@item.keyword).map { |k| k.content.to_s }.reject(&:empty?)
             out[:keyword] = keywords unless keywords.empty?
             out[:URL] = source_uri if source_uri
-            [out].to_json + "\n"
+            Yeptris::JSON.dump([out]) + "\n"
           end
 
           private

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

@@ -44,6 +44,67 @@ module Relaton
       def to_all_parts!; end
 
       def remove_date!; end
+
+      # Docidentifier types with an SDO-specific :external and :internal form
+      # (relaton#49), mapped to the pubid flavor that renders both. The
+      # :external form carries the publisher ("IETF RFC 8341",
+      # "BSI PAS 2031:2019"); the :internal form is the one the SDO uses for its
+      # own documents, without it ("SP 800-113" for "NIST SP 800-113"). pubid
+      # decides per identifier, so "BS EN ISO 8848:2021" and "CGPM RES (1889)"
+      # are the same in both forms. Every other type answers its content for
+      # both forms: pubid would drop "ISO" from an ISO identifier.
+      #
+      # The table keys on `type`, not on a flavor subclass, so it also covers a
+      # relation's nested `Bib::ItemData` and the `Bib::Docidentifier` objects
+      # BIPM and IETF build (a subclass-typed collection would make lutaml's
+      # YAML serializer reject those).
+      FORM_PUBID = {
+        "NIST" => :Nist,
+        "BIPM" => :Bipm,
+        "IETF" => :Ietf,
+        "Internet-Draft" => :Ietf,
+        "BSI" => :Bsi,
+      }.freeze
+
+      FORMS = %i[external internal].freeze
+
+      # The parsed identifier. A pubid-backed flavor subclass overrides it.
+      def pubid; end
+
+      # @param form [Symbol, nil] nil for the stored content, :external for the
+      #   identifier with its publisher, :internal for the form the SDO uses
+      #   for its own documents
+      # @raise [ArgumentError] for an unknown form
+      def to_s(form: nil)
+        return content.to_s unless form
+
+        form = form.to_sym
+        unless FORMS.include?(form)
+          raise ArgumentError, "unknown identifier form: #{form.inspect}"
+        end
+
+        form_content(form).to_s
+      end
+
+      private
+
+      # pubid renders the form (`to_s(with_publisher:)`, pubid#620). A
+      # docidentifier with no parsed pubid (a plain `Bib::Docidentifier`) is
+      # parsed here; content that pubid cannot parse is returned unchanged.
+      def form_content(form)
+        flavor = FORM_PUBID[type]
+        id = flavor && (pubid || parse_form_pubid(flavor))
+        id ? id.to_s(with_publisher: form == :external) : content
+      end
+
+      def parse_form_pubid(flavor)
+        return if content.to_s.empty?
+
+        require "pubid"
+        ::Pubid.const_get(flavor).parse(content)
+      rescue StandardError
+        nil
+      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/bib.rb

@@ -5,6 +5,7 @@ require "bibtex"
 require "iso639"
 require "rfcxml"
 require "relaton/core"
+require "yeptris"
 require_relative "version"
 require_relative "bib/util"
 require_relative "bib/sanitizer"
@@ -41,7 +42,7 @@ module Relaton
     # @return [Hash{String=>String}] schema versions
     #
     def schema_versions
-      @@schema_versions ||= JSON.parse File.read(File.join(__dir__, "bib/versions.json"))
+      @@schema_versions ||= Yeptris::JSON.load File.read(File.join(__dir__, "bib/versions.json"))
     end
   end
 

data/lib/relaton/bipm/CLAUDE.md

@@ -144,6 +144,20 @@ demonstrated rather than argued.
 builds `index-v1` with them, and `id_parser_spec.rb` still covers them. Only
 `bibliography.rb` stopped requiring the file.
 
+### Internal identifier
+
+`docid.to_s(form: :internal)` drops the
+`BIPM` publisher (relaton#49): `BIPM SI Brochure Part 1` →
+`SI Brochure Part 1`. Committee ids (`CGPM RES (1889)`, `CCTF REC 2 (2009)`)
+have no publisher token and are the same in both forms. The rule is the `"BIPM"` row of
+`Bib::Docidentifier::FORM_PUBID`: BIPM docidentifiers carry no pubid,
+so the content is parsed with `Pubid::Bipm` at call time and rendered with
+`to_s(with_publisher: false)`; unparseable content is returned unchanged. It
+also holds for a relation's nested item. Do not move it into a `Bipm::Docidentifier`
+subclass: typing the item's `docidentifier` collection with a subclass makes
+YAML serialization reject the `Bib::Docidentifier` objects the parsers build
+(`IncorrectModelError`).
+
 ### Data Sources
 
 The gem fetches from three external datasets:

data/lib/relaton/bsi/model/docidentifier.rb

@@ -44,10 +44,6 @@ module Relaton
         c if c.is_a?(::Pubid::Bsi::Identifier) || c.is_a?(::Pubid::AllParts)
       end
 
-      def to_s
-        content.to_s
-      end
-
       # Strip the publication date to build a most-recent (undated) reference.
       # pubid's `exclude` propagates into nested identifiers (so a consolidated
       # base date is dropped while the amendment is kept); `:month` is excluded

data/lib/relaton/calconnect/data_fetcher.rb

@@ -1,6 +1,6 @@
+require "yeptris"
 # frozen_string_literal:true
 
-require "json"
 require "mechanize"
 require "relaton/core"
 require "relaton/index"
@@ -54,7 +54,7 @@ module Relaton::Calconnect
       # 304 Not Modified — nothing changed since the last fetch
       return if resp.code == "304"
 
-      data = JSON.parse resp.body
+      data = Relaton::Json.parse_external resp.body
       all_success = true
       Array(data["documents"]).each { |doc| all_success &&= parse_page doc }
       self.etag = resp.response["etag"] if all_success
@@ -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/ccsds/data/fetcher.rb

@@ -1,3 +1,4 @@
+require "yeptris"
 require "json"
 require "mechanize"
 require "relaton/index"
@@ -43,7 +44,7 @@ module Relaton
       #
       def fetch_docs(url)
         resp = agent.get(url)
-        json = JSON.parse resp.body.match(/const config = (.*);/)[1]
+        json = Relaton::Json.parse_external resp.body.match(/const config = (.*);/)[1]
         @array = json["data"].map { |doc| parse_and_save doc, json["data"] }
       end
 

data/lib/relaton/ccsds/model/docidentifier.rb

@@ -60,10 +60,6 @@ module Relaton
         original_content
       end
 
-      def to_s
-        content.to_s
-      end
-
       def to_all_parts!
         return if !@pubid || @pubid.all_parts?
 

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

@@ -1,3 +1,4 @@
+require "yeptris"
 require "fileutils"
 
 module Relaton
@@ -36,6 +37,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 +103,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.
       #
@@ -340,7 +362,7 @@ module Relaton
       def entry_digest(entry)
         require "digest"
         require "json"
-        Digest::SHA256.hexdigest JSON.generate(entry)
+        Digest::SHA256.hexdigest Yeptris::JSON.dump(entry)
       end
 
       # Write, clobbering whatever is there. The caller has already established

data/lib/relaton/core.rb

@@ -1,4 +1,11 @@
 require "relaton/logger"
+
+module Relaton
+  # Registered here as well as in the root entry: flavor files and their
+  # specs load directly via require "relaton/<flavor>", never through
+  # relaton.rb, and the boundary parsers need this constant either way.
+  autoload :Json, "relaton/json"
+end
 require_relative "version"
 require_relative "core/request_error"
 require_relative "core/array_wrapper"