relaton 3.0.3 → 3.0.5

data/lib/relaton/bib/converter/bibxml/to_rfcxml_v3.rb

@@ -0,0 +1,416 @@
+module Relaton
+  module Bib
+    module Converter
+      module BibXml
+        #
+        # Strict RFC 7991 (xml2rfc v3) flavour of {ToRfcxml}.
+        #
+        # It differs from the BibXML output its parent produces in four ways:
+        #
+        # * the deprecated `<format>` element is never emitted;
+        # * identifiers of documents published outside the IETF go into
+        #   `<refcontent>` rather than being forced into `<seriesInfo>`
+        #   (RFC 7991 2.39), as do series that carry no number;
+        # * `<stream>` and the `ascii*` attributes are populated;
+        # * `<front>` is filled out enough to satisfy the v3 grammar, which
+        #   requires a title and at least one author.
+        #
+        class ToRfcxmlV3 < ToRfcxml
+          # Organizations whose documents are "home" standards: their
+          # identifiers are expressible as <seriesInfo>.
+          HOME_ORGS = [
+            "IETF", "Internet Engineering Task Force", "RFC Publisher"
+          ].freeze
+
+          # Identifier types that are already emitted as <seriesInfo> by the
+          # parent, or that never belong in one.
+          NON_AUTHORITATIVE_TYPES = %w[DOI URI].freeze
+
+          # Identifiers metanorma-ietf drops as internal bookkeeping.
+          IGNORED_ID_RE = /\A(rfc-anchor|Internet-Draft)/
+
+          # Series that name the document itself; handled as identifiers.
+          SUBSERIES = %w[BCP STD].freeze
+
+          HOME_ID_RE = /\A(?<name>RFC|BCP|STD|FYI)\s*(?<value>\d+)\z/i
+          # xml2rfc only resolves a draft reference when seriesInfo carries the
+          # full draft name, so keep `draft-…` intact. The `I-D.` anchor form
+          # is a citation label, not the identifier (metanorma-ietf#283).
+          DRAFT_ID_RE = /\A(?<value>draft-\S+)\z/i
+          DRAFT_ANCHOR_RE = /\AI-D[.\s]\s*\S+\z/i
+
+          # Identifier types that duplicate a human-readable identifier or are
+          # bookkeeping rather than citation content (metanorma-ietf#301).
+          EXCLUDED_ID_TYPES = %w[URN].freeze
+
+          # Title parts joined when relaton supplies no composite title.
+          TITLE_PARTS = %w[title-intro title-main title-part].freeze
+
+          # Roles that may stand in for an author when the item names none,
+          # mirroring the released renderer's `creatornames_roles_allowed`.
+          FALLBACK_ROLES = %w[performer adapter translator publisher
+                              distributor authorizer].freeze
+
+          # The values RFC XML v3 allows on <stream>; "editorial" was added by
+          # RFC 9280. Keyed by the spellings the RFC Editor and relaton-ietf
+          # use, so "Independent Submission" is not silently thrown away.
+          STREAMS = {
+            "ietf" => "IETF", "iab" => "IAB", "irtf" => "IRTF",
+            "independent" => "independent",
+            "independent submission" => "independent",
+            "independent submission stream" => "independent",
+            "editorial" => "editorial", "rfc editor" => "editorial",
+            "rfc-editor" => "editorial"
+          }.freeze
+
+          # Latin letters with no NFKD decomposition, which would otherwise be
+          # dropped outright ("Sørensen" -> "Srensen").
+          TRANSLITERATIONS = {
+            "æ" => "ae", "Æ" => "AE", "œ" => "oe", "Œ" => "OE",
+            "ø" => "o", "Ø" => "O", "ß" => "ss", "ẞ" => "SS",
+            "đ" => "d", "Đ" => "D", "ð" => "d", "Ð" => "D",
+            "þ" => "th", "Þ" => "Th", "ł" => "l", "Ł" => "L",
+            "ħ" => "h", "Ħ" => "H", "ŋ" => "ng", "Ŋ" => "NG",
+            "ŧ" => "t", "Ŧ" => "T", "ı" => "i", "ĸ" => "k"
+          }.freeze
+
+          def transform
+            model = ::Rfcxml::V3::Reference.new
+            model.anchor = create_anchor
+            model.target = create_target
+            model.stream = create_stream
+            model.front = create_front
+            model.refcontent = create_refcontent
+            model
+          end
+
+          private
+
+          # The released IETF renderer takes an HTML-typed uri as the reference
+          # target when there is no src (isodoc/ietf/references.rb), and the
+          # transformer does the same; match it here.
+          def target_types = %w[src HTML doi]
+
+          # anchor is mandatory in v3 and is an XML identifier, so fall back
+          # through every source the item has and never leave whitespace in it.
+          def create_anchor
+            sanitize_anchor(@anchor || @item.docnumber || derive_anchor ||
+                            @item.id)
+          end
+
+          def sanitize_anchor(anchor)
+            return nil if anchor.nil?
+
+            anchor.to_s.strip.gsub(/\s+/, ".")
+          end
+
+          # <front> needs a title and at least one author to be valid v3.
+          def create_front
+            front = super
+            front.title = compound_title || formattedref_title
+            front.author = [unknown_author] if Array(front.author).empty?
+            front
+          end
+
+          # The base emitter takes title[0], which on a multipart standard is
+          # the intro alone ("IT Security techniques"). A citation needs the
+          # whole compound, so prefer the composite title relaton builds, then
+          # the intro-main-part join, then whatever is first.
+          def compound_title
+            content = composite_title || joined_title ||
+              @item.title.first&.content
+            return nil if content.nil?
+
+            ::Rfcxml::V3::Title.new(content: plain_text(content))
+          end
+
+          def composite_title
+            @item.title.find { |t| t.type == "main" }&.content
+          end
+
+          def joined_title
+            parts = TITLE_PARTS.filter_map do |type|
+              @item.title.find { |t| t.type == type }&.content
+            end
+            parts.empty? ? nil : parts.join(" - ")
+          end
+
+          def formattedref_title
+            content = @item.formattedref&.content or return nil
+
+            ::Rfcxml::V3::Title.new(content: plain_text(content))
+          end
+
+          # v3 <title> is text-only, so inline markup a formattedref or title
+          # carries has to be flattened rather than escaped into the output.
+          def plain_text(content)
+            text = content.to_s
+            return text unless text.include?("<")
+
+            Nokogiri::XML.fragment(text).text.squeeze(" ").strip
+          end
+
+          def unknown_author
+            ::Rfcxml::V3::Author.new(surname: "Unknown")
+          end
+
+          # One <seriesInfo> per (name, value): the same identifier can arrive
+          # from a docidentifier and a series, or from two docidentifiers that
+          # spell it differently ("RFC 2119" and "RFC2119").
+          def create_seriesinfo
+            (docidentifier_to_seriesinfo + series_to_seriesinfo +
+              identifier_to_seriesinfo).uniq { |si| [si.name, si.value] }
+          end
+
+          # Only series that carry a number can become <seriesInfo>; the rest
+          # are rendered as <refcontent>.
+          def series_to_seriesinfo
+            numbered_series.map do |ser|
+              ::Rfcxml::V3::SeriesInfo.new(name: series_title(ser).content,
+                                           value: ser.number)
+            end
+          end
+
+          def numbered_series
+            renderable_series.select(&:number)
+          end
+
+          # Series that are neither the stream marker nor a restatement of
+          # something already rendered from the document's identifiers. Only
+          # names actually emitted elsewhere are dropped: a series such as
+          # Internet-Draft still carries its number when no docidentifier
+          # supplies one.
+          def renderable_series
+            @item.series.reject { |ser| skip_series?(ser) }
+              .uniq { |ser| series_title(ser).content }
+          end
+
+          def skip_series?(ser)
+            return true if ser.type == "stream"
+
+            title = series_title(ser)
+            title.nil? || title.content.to_s == "DOI" ||
+              identifier_series_names.include?(title.content.to_s)
+          end
+
+          # Series names already covered by <seriesInfo> or <refcontent> built
+          # from the item's identifiers.
+          def identifier_series_names
+            @identifier_series_names ||=
+              identifier_to_seriesinfo.map(&:name) +
+              subseries_identifiers.map { |id| id.split.first }
+          end
+
+          def series_title(ser)
+            ser.title.find { |title| title.content.to_s != "DOI" }
+          end
+
+          # --- Identifiers ---
+
+          def identifier_to_seriesinfo
+            return [] unless home_standard?
+
+            authoritative_identifiers.filter_map { |id| id_to_seriesinfo(id) }
+          end
+
+          def id_to_seriesinfo(id)
+            name, value = split_identifier(id)
+            return nil unless name
+
+            # No `stream` attribute here: in v3 the stream is carried by the
+            # <stream> element, and duplicating it only adds noise.
+            ::Rfcxml::V3::SeriesInfo.new(name: name, value: value,
+                                         status: seriesinfo_status)
+          end
+
+          def split_identifier(id)
+            if (match = DRAFT_ID_RE.match(id))
+              ["Internet-Draft", match[:value]]
+            elsif (match = HOME_ID_RE.match(id))
+              [match[:name].upcase, match[:value]]
+            end
+          end
+
+          # An untyped docidentifier that merely restates the reference's own
+          # label ("ZELLER", "Grail") is a citation label, not a citation: keep
+          # it only when the reference would otherwise show nothing at all.
+          def label_echo?(docid)
+            return false unless docid.type.nil?
+
+            docid.content.to_s.casecmp(label_candidates.to_s).zero? &&
+              reference_has_visible_text?
+          end
+
+          def label_candidates
+            @item.docnumber || @item.id
+          end
+
+          def reference_has_visible_text?
+            @item.title.any? || @item.formattedref ||
+              @item.contributor.any? || @item.date.any?
+          end
+
+          def seriesinfo_status
+            @item.status&.stage&.content
+          end
+
+          def authoritative_identifiers
+            ids = subseries_identifiers + docidentifier_identifiers
+            ids.reject { |id| id.empty? || IGNORED_ID_RE.match?(id) }.uniq
+          end
+
+          def docidentifier_identifiers
+            @item.docidentifier.reject { |di| non_authoritative?(di) }
+              .map { |di| di.content.to_s.strip }
+          end
+
+          def non_authoritative?(docid)
+            NON_AUTHORITATIVE_TYPES.include?(docid.type) ||
+              EXCLUDED_ID_TYPES.include?(docid.type) ||
+              docid.scope == "trademark" ||
+              DRAFT_ANCHOR_RE.match?(docid.content.to_s) ||
+              label_echo?(docid)
+          end
+
+          def subseries_identifiers
+            @item.series.filter_map do |ser|
+              title = ser.title.find { |t| SUBSERIES.include?(t.content.to_s) }
+              "#{title.content} #{ser.number}" if title && ser.number
+            end
+          end
+
+          def home_standard?
+            @item.contributor.any? do |contrib|
+              org = contrib.organization or next false
+
+              ([org.abbreviation&.content] + org.name.map(&:content))
+                .compact.any? { |name| HOME_ORGS.include?(name.to_s) }
+            end
+          end
+
+          # --- refcontent ---
+
+          def create_refcontent
+            (identifier_refcontent + series_refcontent)
+              .map { |text| ::Rfcxml::V3::Refcontent.new(content: text) }
+          end
+
+          # Identifiers that cannot be expressed as <seriesInfo> — either
+          # because the document is not an IETF one, or because the identifier
+          # does not split into a series name and number.
+          # Whatever <seriesInfo> already states must not be repeated here,
+          # whichever route put it there.
+          def identifier_refcontent
+            ids = authoritative_identifiers.reject { |id| in_seriesinfo?(id) }
+            ids.empty? ? [] : [ids.join(", ")]
+          end
+
+          def in_seriesinfo?(id)
+            name, value = split_identifier(id)
+            return false if name.nil?
+
+            create_seriesinfo.any? { |si| si.name == name && si.value == value }
+          end
+
+          def series_refcontent
+            (renderable_series - numbered_series).filter_map do |ser|
+              text = ser.formattedref&.content&.to_s || series_description(ser)
+              text unless text.strip.empty?
+            end
+          end
+
+          def series_description(ser)
+            [series_title(ser)&.content, ser.run, ser.organization,
+             ser.place&.city, series_dates(ser)]
+              .map(&:to_s).reject(&:empty?).join(", ")
+          end
+
+          def series_dates(ser)
+            [ser.from, ser.to].compact.map(&:to_s).reject(&:empty?).join("-")
+          end
+
+          # --- stream ---
+
+          # Values outside the grammar (relaton-ietf also has "Legacy") have no
+          # valid representation, so they are dropped with a warning rather
+          # than emitted as invalid XML.
+          def create_stream
+            value = ext_stream || series_stream
+            return nil if value.nil?
+
+            stream = STREAMS[value.to_s.strip.downcase]
+            unless stream
+              Util.warn "Dropping stream `#{value}`: not an RFC XML v3 stream"
+            end
+            stream
+          end
+
+          def ext_stream
+            @item.ext.respond_to?(:stream) ? @item.ext.stream : nil
+          end
+
+          def series_stream
+            ser = @item.series.find { |s| s.type == "stream" }
+            ser && ser.title.first&.content
+          end
+
+          # --- Contributors ---
+
+          # Every relaton-ietf RFC record carries publisher and authorizer
+          # contributors, and published RFC XML never lists those as authors.
+          # So: authors and editors if there are any, and only otherwise fall
+          # back to the wider set, which keeps a translator-only monograph its
+          # translator (metanorma-ietf#301).
+          def contributors_for_authors
+            contribs = super
+            primary = contribs.select { |c| role?(c, %w[author editor]) }
+            primary.any? ? primary : contribs.select { |c| fallback_author?(c) }
+          end
+
+          def role?(contrib, types)
+            contrib.role.any? { |r| types.include?(r.type) }
+          end
+
+          # A contributor with no role at all is an author by default; that is
+          # how most non-IETF bibitems are written.
+          def fallback_author?(contrib)
+            contrib.role.empty? || role?(contrib, FALLBACK_ROLES)
+          end
+
+          # --- ascii folding ---
+
+          def create_authors
+            super.each do |author|
+              author.ascii_fullname = ascii(author.fullname)
+              author.ascii_surname = ascii(author.surname)
+              author.ascii_initials = ascii(author.initials)
+            end
+          end
+
+          def create_organization(contrib)
+            org = super or return nil
+
+            org.ascii = ascii(Array(org.content).join)
+            org
+          end
+
+          # Transliterate to bare ASCII: expand the letters above, then strip
+          # the combining marks NFKD leaves behind. "Nürk" -> "Nurk",
+          # "Ö." -> "O.", "Sørensen" -> "Sorensen".
+          def ascii(str)
+            return nil if str.nil?
+
+            folded = str.to_s.gsub(/[#{TRANSLITERATIONS.keys.join}]/,
+                                   TRANSLITERATIONS)
+              .unicode_normalize(:nfkd)
+              .encode("ASCII", invalid: :replace, undef: :replace, replace: "")
+            # Folding a non-Latin script leaves only the punctuation and
+            # spacing behind ("Νίκος Παπαδόπουλος" -> " "), which is worse than
+            # no attribute at all. Real transliteration is the caller's policy.
+            folded.match?(/[[:alnum:]]/) ? folded : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/converter/bibxml.rb

@@ -1,5 +1,7 @@
 require_relative "bibxml/to_rfcxml"
 require_relative "bibxml/to_rfcxml_referencegroup"
+require_relative "bibxml/to_rfcxml_v3"
+require_relative "bibxml/to_rfcxml_referencegroup_v3"
 require_relative "bibxml/from_rfcxml"
 require_relative "bibxml/from_rfcxml_referencegroup"
 
@@ -16,17 +18,27 @@ module Relaton
         RFCPREFIXES = %w[RFC BCP FYI STD].freeze
 
         # Forward: ItemData -> Rfcxml model
-        def self.from_item(item, include_keywords: true) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          if bcp?(item)
-            ToRfcxmlReferencegroup.new(
-              item, include_keywords: include_keywords
-            ).transform
-          else
-            ToRfcxml.new(
-              item, include_keywords: include_keywords
-            ).transform
+        #
+        # @param v3 [Boolean] emit strict RFC 7991 (xml2rfc v3) instead of the
+        #   BibXML shape the relaton data fetchers publish
+        # @param anchor [String, nil] anchor to use instead of the one derived
+        #   from the item's docnumber/docidentifier
+        def self.from_item(item, include_keywords: true, v3: false, anchor: nil) # rubocop:disable Naming/MethodParameterName
+          klass = if v3 then v3_converter(item)
+                  elsif bcp?(item) then ToRfcxmlReferencegroup
+                  else ToRfcxml
+                  end
+          klass.new(item, include_keywords: include_keywords,
+                          anchor: anchor).transform
+        end
+
+        def self.v3_converter(item)
+          if item.relation.any? { |rel| rel.type == "includes" }
+            ToRfcxmlReferencegroupV3
+          else ToRfcxmlV3
           end
         end
+        private_class_method :v3_converter
 
         def self.bcp?(item) # rubocop:disable Metrics/CyclomaticComplexity
           item.docnumber&.match(/^BCP/) ||

data/lib/relaton/bib/item_data.rb

@@ -19,8 +19,18 @@ module Relaton
       COLLECTION_WRITE_ONLY_ATTRIBUTES = %i[title abstract source relation].freeze
 
       ATTRIBUTES.each { |attr| attr_accessor attr }
-      COLLECTION_ATTRBUTES.each { |attr| attr_accessor attr }
-      COLLECTION_WRITE_ONLY_ATTRIBUTES.each { |attr| attr_writer attr }
+      COLLECTION_ATTRBUTES.each { |attr| attr_reader attr }
+
+      # Collections are always arrays. lutaml-model assigns every mapped
+      # attribute after building the instance, so an element absent from the
+      # XML would otherwise overwrite the [] set in #initialize with nil --
+      # `Item.from_xml` items then blew up in any consumer that iterated them,
+      # while `from_yaml` ones did not.
+      (COLLECTION_ATTRBUTES + COLLECTION_WRITE_ONLY_ATTRIBUTES).each do |attr|
+        define_method("#{attr}=") do |value|
+          instance_variable_set("@#{attr}", array(value))
+        end
+      end
 
       attr_reader :id, :docidentifier
 
@@ -28,10 +38,10 @@ module Relaton
         ATTRIBUTES.each { |attr| instance_variable_set("@#{attr}", args[attr]) }
 
         (COLLECTION_ATTRBUTES + COLLECTION_WRITE_ONLY_ATTRIBUTES).each do |attr|
-          instance_variable_set("@#{attr}", args[attr] || [])
+          instance_variable_set("@#{attr}", array(args[attr]))
         end
 
-        @docidentifier = args[:docidentifier] || []
+        @docidentifier = array(args[:docidentifier])
         self.schema_version = schema
         @id = args[:id]
         create_id
@@ -42,7 +52,7 @@ module Relaton
       end
 
       def docidentifier=(value)
-        @docidentifier = value || []
+        @docidentifier = array(value)
         create_id
       end
 
@@ -179,8 +189,10 @@ module Relaton
         Converter::Asciibib.from_item(self)
       end
 
-      def to_rfcxml
-        Converter::BibXml.from_item(self).to_xml
+      # @param opts [Hash] passed to {Converter::BibXml.from_item}; notably
+      #   `v3: true` for strict RFC 7991 output instead of BibXML.
+      def to_rfcxml(**)
+        Converter::BibXml.from_item(self, **).to_xml
       end
 
       def deep_clone

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

@@ -11,6 +11,11 @@ module Relaton
       key_value do
         map "format", to: :format
       end
+
+      # biblio.rng admits basicdoc blocks in <abstract> only.
+      def sanitizer_allowed
+        Relaton::Bib::Sanitizer::ALLOWED_WITH_BLOCKS
+      end
     end
   end
 end

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

@@ -28,10 +28,15 @@ module Relaton
     class LocalizedMarkedUpString < LocalizedStringAttrs
       module ContentSanitization
         def content=(value)
-          super(Relaton::Bib::Sanitizer.sanitize(value))
+          super(Sanitizer.sanitize(value, allowed: sanitizer_allowed))
         end
       end
 
+      # The elements that content keeps; Abstract widens it to blocks.
+      def sanitizer_allowed
+        Relaton::Bib::Sanitizer::ALLOWED
+      end
+
       # Cast at the assignment layer (lutaml-model#972): a bare scalar
       # assigned to a singular custom-typed attribute (e.g. a relation's
       # description) is wrapped here, so the serializer's type validation

data/lib/relaton/bib/sanitizer.rb

@@ -24,12 +24,27 @@ module Relaton
     # 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.
+    #
+    # ALLOWED_WITH_BLOCKS adds the basicdoc block elements: lists, notes,
+    # tables, figures and admonitions, with the children that their grammar
+    # requires (a caption <name>, <thead>/<tbody>/<tfoot>, a figure's
+    # <image>). Only Abstract asks for it, because <abstract> is the one
+    # field whose grammar admits blocks; a title or a note admits only
+    # PureTextElement. Before relaton#421 an abstract's list or note
+    # unwrapped in place and came back as bare paragraphs, with no error.
     module Sanitizer
       ALLOWED = %w[
         em strong sub sup tt underline strike smallcap br stem
         p eref xref fn link
       ].freeze
 
+      BLOCK = %w[
+        ul ol li dl dt dd note admonition
+        table thead tbody tfoot tr td th figure name image
+      ].freeze
+
+      ALLOWED_WITH_BLOCKS = (ALLOWED + BLOCK).freeze
+
       # Elements whose children are non-basicdoc inline notation
       # (MathML, AsciiMath, LaTeX, …) and must be preserved verbatim
       # rather than sanitised against ALLOWED.
@@ -63,13 +78,13 @@ module Relaton
       # Reserved prefixes. XML declares both, so the content must not.
       NS_RESERVED = %w[xml xmlns].freeze
 
-      def self.sanitize(content)
+      def self.sanitize(content, allowed: ALLOWED)
         return content unless sanitizable?(content)
 
         node = parse(content)
         return content if node.nil?
 
-        sanitize_children(node)
+        sanitize_children(node, allowed)
         node.children.map { |c| c.to_xml(encoding: "UTF-8", indent: 0, expand_empty: false) }.join
       end
 
@@ -273,15 +288,15 @@ module Relaton
       end
       private_class_method :sanitizable?
 
-      def self.sanitize_children(node)
+      def self.sanitize_children(node, allowed)
         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)
-          unwrap(child) unless ALLOWED.include?(child.name)
+          sanitize_children(child, allowed)
+          unwrap(child) unless allowed.include?(child.name)
         end
       end
       private_class_method :sanitize_children

data/lib/relaton/bipm/data_outcomes_parser.rb

@@ -1,3 +1,4 @@
+require "yeptris/psych"
 module Relaton::Bipm
   class DataOutcomesParser
     SHORTTYPE = {
@@ -130,7 +131,7 @@ module Relaton::Bipm
       fr_file = en_file.sub "en", "fr"
       [en_file, fr_file].map do |file|
         if File.exist? file
-          data = YAML.safe_load(File.read(file, encoding: "UTF-8"))
+          data = Yeptris::Psych.safe_load(File.read(file, encoding: "UTF-8"))
           path = file
         end
         [path, data]

data/lib/relaton/bipm/si_brochure_parser.rb

@@ -1,3 +1,4 @@
+require "yeptris/psych"
 require "moxml"
 
 module Relaton::Bipm
@@ -60,8 +61,8 @@ module Relaton::Bipm
             warn_duplicate = false
             item2 = Item.from_yaml File.read(outfile, encoding: "UTF-8")
             fix_si_brochure_id item2
-            hash1 = YAML.safe_load item1.to_yaml
-            hash2 = YAML.safe_load item2.to_yaml
+            hash1 = Yeptris::Psych.safe_load item1.to_yaml
+            hash2 = Yeptris::Psych.safe_load item2.to_yaml
             Item.from_yaml deep_merge(hash1, hash2).to_yaml
           else
             warn_duplicate = true

data/lib/relaton/core/data_fetcher.rb

@@ -1,3 +1,4 @@
+require "yeptris/psych"
 require "yeptris"
 require "fileutils"
 
@@ -121,7 +122,7 @@ module Relaton
         kept = ledger.merge(ledger_new).select do |_, row|
           row.is_a?(Hash) && row["file"] && @written.include?(row["file"])
         end
-        File.write ledger_path, YAML.dump(kept), encoding: "UTF-8"
+        File.write ledger_path, Yeptris::Psych.dump(kept), encoding: "UTF-8"
         @ledger = kept
       end
 
@@ -349,7 +350,7 @@ module Relaton
 
       def ledger
         @ledger ||= if File.exist?(ledger_path)
-                      YAML.safe_load_file(ledger_path) || {}
+                      Yeptris::Psych.safe_load_file(ledger_path) || {}
                     else
                       {}
                     end