relaton 3.0.0.pre.alpha.4 → 3.0.0.pre.alpha.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2c4c35d668277f91fb1ad11eafe4da0b25f49fe9110ac81df83d8bae5bebcac
-  data.tar.gz: 6d0e6ce6134990d786cb67fc20c1a90a1992ced44907191e03340f3a34702c0c
+  metadata.gz: b34a85f74b2b8b07d61b51a20d976f1204240dbc353f9e7d73eeeb7262912337
+  data.tar.gz: 6e51891af83e32391abb096a788685f42d7cc648fc6a3e3483683868daa8e4b3
 SHA512:
-  metadata.gz: dff41b1c067bc5eb8a5737b1fa6dc927dc9ef0d0b04a8e33a7bc4d637c6c78a99bbb8f4ec7cd3aeee5682cab61f099b4d15952884b990da8020db6fe9122df0d
-  data.tar.gz: 77c8b1aba1fb16829882b3e311416db6e2481d3800c898148810203d0805a4bd0caef2960831a464b44f9e357aff1cdad6cc9573dc02473518179621acf7f1b0
+  metadata.gz: 6530a4f026cf099bcd3a1c1b359d307089b57bbe14f94a77362adabafa329abbcb4f64349feaa9061e9a6eda9ff413645af6b14812bdcb3ac9bcb4e22e6ad0a1
+  data.tar.gz: 7c555c9ddb34285255f22766b7b9c56be98b657018bfb4503bb66bc316eea7a1c2fd796f21e1910ad41615a0079d8db32f76d2b46bc051a2a4e7c6ed4c0316cc

data/lib/relaton/adobe/processor.rb

@@ -12,6 +12,7 @@ module Relaton
       def initialize
         @short = :relaton_adobe
         @prefix = "Adobe"
+        @pubid_identifier = :Adobe # Db cache key
         @defaultprefix = %r{^(?:Adobe|ATN)}
         @idtype = "Adobe"
       end
@@ -21,6 +22,14 @@ module Relaton
         Bibliography.get(code, date, opts)
       end
 
+      # `Bibliography.get` reads a reference pubid cannot parse as a miss
+      # (`pubid_for`), so it gets no key here either: it is not cached.
+      def cache_pubid(ref)
+        super
+      rescue StandardError
+        nil
+      end
+
       def from_xml(xml)
         require_relative "../adobe"
         Item.from_xml xml

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Relaton
+  module Bib
+    module Converter
+      # CSL-JSON serialization — the Citation Style Language interchange
+      # format consumed by Zotero, Mendeley, and every citeproc.
+      module Csl
+        ENTRY_TYPES = {
+          "standard" => "standard", "book" => "book",
+          "article" => "article-journal", "inbook" => "chapter",
+          "inproceedings" => "paper-conference", "report" => "report",
+          "thesis" => "thesis", "website" => "webpage",
+          "webresource" => "webpage",
+        }.freeze
+
+        def self.from_item(item)
+          Renderer.new(item).to_s
+        end
+
+        class Renderer
+          def initialize(item)
+            @item = item
+          end
+
+          def to_s
+            out = {}
+            docid = primary_docid
+            out[:id] = docid.empty? ? "relaton" : docid
+            out[:type] = ENTRY_TYPES[@item.type.to_s] || "standard"
+            out[:title] = primary_title unless primary_title.empty?
+            authors = csl_authors
+            out[:author] = authors unless authors.empty?
+            out[:issued] = { "date-parts" => [[published_year]] } unless published_year.empty?
+            publisher = publisher_name
+            out[:publisher] = publisher unless publisher.empty?
+            out[:number] = docid unless docid.empty?
+            out[:edition] = @item.edition.to_s unless @item.edition.to_s.empty?
+            lang = Array(@item.language).first
+            out[:language] = lang.to_s if lang
+            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"
+          end
+
+          private
+
+          def csl_authors
+            Array(@item.contributor).filter_map do |c|
+              roles = Array(c.role).map(&:type).compact
+              next unless (roles & %w[author performer editor]).any?
+
+              if c.person
+                name = c.person.name
+                fore = name ? Array(name.forename).map { |f| f.respond_to?(:content) ? f.content.to_s : f.to_s }.join(" ") : ""
+                sur = name && name.surname.respond_to?(:content) ? name.surname.content.to_s : name&.surname.to_s
+                complete = name && name.completename.respond_to?(:content) ? name.completename.content.to_s : name&.completename.to_s
+                if sur.to_s.empty?
+                  complete.to_s.empty? ? nil : { "literal" => complete }
+                else
+                  entry = { "family" => sur }
+                  entry["given"] = fore unless fore.empty?
+                  entry
+                end
+              elsif c.organization
+                literal = org_name(c.organization)
+                literal.empty? ? nil : { "literal" => literal }
+              end
+            end
+          end
+
+          def org_name(org)
+            name = Array(org.name).map { |n| n.respond_to?(:content) ? n.content.to_s : n.to_s }.find(&:itself)
+            name || org.abbreviation.to_s
+          end
+
+          def publisher_name
+            pub = Array(@item.contributor).find do |c|
+              Array(c.role).map(&:type).include?("publisher") && c.organization
+            end
+            pub ? org_name(pub.organization) : ""
+          end
+
+          def primary_title
+            Titles.of(@item)
+          end
+
+          def primary_docid
+            ids = Array(@item.docidentifier)
+            (ids.find(&:primary) || ids.first)&.content.to_s
+          end
+
+          def published_year
+            date = Array(@item.date).find { |d| %w[published issued].include?(d.type.to_s) } || @item.date.first
+            value = date && (date.at || date.from || date.to)
+            value.to_s[/\d{4}/]
+          end
+
+          def source_uri
+            Array(@item.source).map { |s| s.respond_to?(:content) ? s.content.to_s : s.to_s }
+              .find { |u| u.start_with?("http") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+
+module Relaton
+  module Bib
+    module Converter
+      # RIS serialization — the interchange format for EndNote, Zotero,
+      # and Reference Manager. Standards map to TY - STD.
+      module Ris
+        ENTRY_TYPES = {
+          "standard" => "STD", "book" => "BOOK", "article" => "JOUR",
+          "inbook" => "CHAP", "inproceedings" => "CONF", "report" => "RPRT",
+          "thesis" => "THES", "website" => "ELEC", "webresource" => "ELEC",
+        }.freeze
+
+        def self.from_item(item)
+          Renderer.new(item).to_s
+        end
+
+        class Renderer
+          def initialize(item)
+            @item = item
+          end
+
+          def to_s
+            lines = ["TY  - #{ENTRY_TYPES[@item.type.to_s] || 'STD'}"]
+            add_authors(lines)
+            add_field(lines, "TI", primary_title)
+            add_field(lines, "ID", primary_docid)
+            add_field(lines, "PY", published_year)
+            add_field(lines, "ET", @item.edition&.to_s)
+            lang = Array(@item.language).first
+            add_field(lines, "LA", lang.to_s)
+            Array(@item.keyword).each { |k| add_field(lines, "KW", k.content.to_s) }
+            add_field(lines, "UR", source_uri)
+            lines << "ER  - "
+            lines.join("\r\n") + "\r\n"
+          end
+
+          private
+
+          def add_field(lines, tag, value)
+            lines << "#{tag}  - #{value}" if value && !value.empty?
+          end
+
+          def add_authors(lines)
+            Array(@item.contributor).each do |c|
+              roles = Array(c.role).map(&:type).compact
+              authorish = (roles & %w[author performer editor]).any?
+              publisher = roles.include?("publisher")
+              if authorish && c.person
+                out = person_display_name(c.person.name)
+                lines << "AU  - #{out}" unless out.empty?
+              elsif authorish && c.organization
+                out = org_name(c.organization)
+                lines << "AU  - #{out}" unless out.empty?
+              elsif publisher && c.organization
+                out = org_name(c.organization)
+                lines << "PB  - #{out}" unless out.empty? || lines.any? { |l| l.start_with?("PB  - ") }
+              end
+            end
+          end
+
+          def person_display_name(name)
+            return "" unless name
+
+            fore = Array(name.forename).map { |f| f.respond_to?(:content) ? f.content.to_s : f.to_s }.join(" ")
+            sur = name.surname.respond_to?(:content) ? name.surname.content.to_s : name.surname.to_s
+            complete = name.completename.respond_to?(:content) ? name.completename.content.to_s : name.completename.to_s
+            return "#{sur}, #{fore}" unless fore.empty? || sur.empty?
+            return sur unless sur.empty?
+
+            complete
+          end
+
+          def org_name(org)
+            name = Array(org.name).map { |n| n.respond_to?(:content) ? n.content.to_s : n.to_s }.find(&:itself)
+            name || org.abbreviation.to_s
+          end
+
+          def primary_title
+            Titles.of(@item)
+          end
+
+          def primary_docid
+            ids = Array(@item.docidentifier)
+            (ids.find(&:primary) || ids.first)&.content.to_s
+          end
+
+          def published_year
+            date = Array(@item.date).find { |d| %w[published issued].include?(d.type.to_s) } || @item.date.first
+            value = date && (date.at || date.from || date.to)
+            value.to_s[/\d{4}/]
+          end
+
+          def source_uri
+            Array(@item.source).map { |s| s.respond_to?(:content) ? s.content.to_s : s.to_s }
+              .find { |u| u.start_with?("http") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Bib
+    module Converter
+      # Single citation language; decomposed titles compose, composite or
+      # plain titles stand alone. Shared by every export converter.
+      module Titles
+        def self.of(item)
+          titles = Array(item.title).select { |t| t.content.to_s != "" }
+          content = ->(t) { t&.content.to_s }
+          intro = titles.find { |t| t.type == "title-intro" }
+          main = titles.find { |t| t.type == "title-main" }
+          part = titles.find { |t| t.type == "title-part" }
+          composite = titles.find { |t| t.type == "main" }
+          base = [content.call(intro), content.call(main)].reject(&:empty?)
+          base = [content.call(composite)].reject(&:empty?) if base.empty?
+          base = [content.call(titles.first)].reject(&:empty?) if base.empty?
+          [*base, content.call(part)].reject(&:empty?).join(" — ")
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/item_data.rb

@@ -152,6 +152,15 @@ module Relaton
         Converter::Bibtex.from_item(self).to_s
       end
 
+      def to_ris
+        Converter::Ris.from_item(self)
+      end
+
+      def to_csl_json
+        Converter::Csl.from_item(self)
+      end
+
+
       def to_asciibib
         Converter::Asciibib.from_item(self)
       end

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

@@ -46,10 +46,6 @@ require_relative "ext"
 require_relative "item_shared"
 require_relative "type/plain_date"
 
-Lutaml::Model::Config.configure do |config|
-  config.xml_adapter_type = :nokogiri
-end
-
 module Relaton
   module Bib
     class Relation < Lutaml::Model::Serializable
@@ -69,8 +65,12 @@ module Relaton
 
         # lutaml-model has no built-in dispatch on root element name
         # (polymorphic_map only works on attribute discriminators), so we
-        # peek at the root tag with Nokogiri and forward to the right class.
-        root_name = Nokogiri::XML(xml.to_s).root&.name
+        # peek at the root tag with moxml and forward to the right class.
+        root_name = begin
+          Moxml.parse(xml.to_s).root&.name
+        rescue Moxml::ParseError
+          nil
+        end
         klass = root_name == "bibdata" ? namespace::Bibdata : namespace::Bibitem
         klass.from_xml(xml, options)
       end

data/lib/relaton/bib/sanitizer.rb

@@ -1,4 +1,4 @@
-require "nokogiri"
+require "moxml"
 
 module Relaton
   module Bib
@@ -63,11 +63,6 @@ module Relaton
       # Reserved prefixes. XML declares both, so the content must not.
       NS_RESERVED = %w[xml xmlns].freeze
 
-      # Serialise without the FORMAT option, so the sanitiser keeps the
-      # shape of element-only content instead of adding newlines and
-      # indent.
-      SAVE_OPTS = Nokogiri::XML::Node::SaveOptions::AS_XML
-
       def self.sanitize(content)
         return content unless sanitizable?(content)
 
@@ -75,9 +70,7 @@ module Relaton
         return content if node.nil?
 
         sanitize_children(node)
-        node.children.map do |c|
-          c.to_xml(encoding: "UTF-8", save_with: SAVE_OPTS)
-        end.join
+        node.children.map { |c| c.to_xml(encoding: "UTF-8", indent: 0, expand_empty: false) }.join
       end
 
       #
@@ -85,13 +78,23 @@ module Relaton
       #
       # @param [String] content The raw marked-up content.
       #
-      # @return [Nokogiri::XML::Node, nil] The node, or nil when the
-      #   content does not parse.
+      # @return [Moxml::Element, nil] The wrapper element, or nil when
+      #   the content does not parse.
       #
+      # moxml's parse_fragment returns detached nodes without a parent
+      # chain, so the document that owns their C memory can be collected
+      # while the node wrappers live on. Parse under a synthetic root
+      # instead — the same wrapper machinery parse_with_prefixes uses —
+      # which keeps the document reachable from the root.
       def self.parse(content)
-        fragment = Nokogiri::XML::DocumentFragment.parse(content)
-        return fragment if fragment.errors.empty?
+        # leptris accepts undeclared prefixes instead of failing the
+        # parse, so detect them by scan and take the placeholder path
+        # directly.
+        return parse_with_prefixes(content) if placeholder_declarations(content)
 
+        name = wrapper_name(content)
+        Moxml.parse("<#{name}>#{content}</#{name}>").root
+      rescue Moxml::ParseError
         parse_with_prefixes(content)
       end
       private_class_method :parse
@@ -112,16 +115,16 @@ module Relaton
       #
       # @param [String] content The raw marked-up content.
       #
-      # @return [Nokogiri::XML::Element, nil] The wrapper element, or nil
+      # @return [Moxml::Element, nil] The wrapper element, or nil
       #   when the content uses no prefix or does not parse.
       #
       def self.parse_with_prefixes(content)
         decl = placeholder_declarations(content) or return
         name = wrapper_name(content)
-        doc = Nokogiri::XML "<#{name} #{decl}>#{content}</#{name}>"
-        return unless doc.errors.empty?
-
+        doc = Moxml.parse "<#{name} #{decl}>#{content}</#{name}>"
         drop_placeholder_namespaces doc.root
+      rescue Moxml::ParseError
+        nil
       end
       private_class_method :parse_with_prefixes
 
@@ -183,20 +186,41 @@ module Relaton
       # reach the output, so the declarations never leak. Do not
       # serialise the root itself.
       #
-      # @param [Nokogiri::XML::Element] root The wrapper element.
+      # @param [Moxml::Element] root The wrapper element.
       #
-      # @return [Nokogiri::XML::Element] The same element.
+      # @return [Moxml::Element] The same element.
       #
       def self.drop_placeholder_namespaces(root)
         placeholders = root.namespace_definitions
-        root.traverse do |node|
-          node.namespace = nil if placeholders.include?(node.namespace)
+        traverse(root) do |node|
+          if node.element? && placeholder_bound?(node, placeholders)
+            # moxml keeps the prefix in the C node name; renaming to the
+            # local name is the un-prefix operation.
+            node.name = node.name
+          end
           next unless node.element?
 
           drop_attribute_namespaces node, placeholders
         end
         root
       end
+
+      # Is the node bound to a wrapper placeholder rather than to a
+      # namespace it declares itself? A content element may re-declare
+      # the same prefix and URI (spec: "keeps a namespace that reuses
+      # the placeholder URI"); that declaration is its own, not the
+      # wrapper's, and must survive.
+      def self.placeholder_bound?(node, placeholders)
+        ns = node.namespace
+        return false unless placeholders.include?(ns)
+
+        # declared_namespaces yields Namespace wrappers or [prefix,
+        # uri] pairs depending on the adapter path.
+        node.declared_namespaces.none? do |own|
+          prefix, uri = own.respond_to?(:prefix) ? [own.prefix, own.uri] : own
+          prefix == ns.prefix && uri == ns.uri
+        end
+      end
       private_class_method :drop_placeholder_namespaces
 
       #
@@ -208,21 +232,23 @@ module Relaton
       # target redefined" -- the unparseable output this whole path
       # exists to prevent. Drop the prefixed one instead.
       #
-      # @param [Nokogiri::XML::Element] node The element.
-      # @param [Array<Nokogiri::XML::Namespace>] placeholders The
-      #   wrapper's own declarations.
+      # @param [Moxml::Element] node The element.
+      # @param [Array] placeholders The wrapper's own declarations.
       #
       # @return [void]
       #
       def self.drop_attribute_namespaces(node, placeholders)
-        node.attribute_nodes.each do |attr|
+        node.attributes.each do |attr|
           next unless placeholders.include?(attr.namespace)
 
-          if plain_attribute?(node, attr.name) then attr.unlink
-          else attr.namespace = nil
+          if plain_attribute?(node, attr.name) then attr.remove
+          else attr.name = attr.name
           end
         end
       end
+      # (attribute prefixes: a content element that re-declares the
+      # placeholder keeps its prefixed attributes — the placeholder is
+      # out of scope for them the same way it is for element names)
       private_class_method :drop_attribute_namespaces
 
       #
@@ -232,13 +258,13 @@ module Relaton
       # the prefixed attribute itself and every un-prefixing would look
       # like a collision. Match on the namespace as well.
       #
-      # @param [Nokogiri::XML::Element] node The element.
+      # @param [Moxml::Element] node The element.
       # @param [String] name The un-prefixed attribute name.
       #
       # @return [Boolean] Whether the element carries it.
       #
       def self.plain_attribute?(node, name)
-        node.attribute_nodes.any? { |a| a.namespace.nil? && a.name == name }
+        node.attributes.any? { |a| a.namespace.nil? && a.name == name }
       end
       private_class_method :plain_attribute?
 
@@ -255,10 +281,25 @@ module Relaton
           next if OPAQUE.include?(child.name)
 
           sanitize_children(child)
-          child.replace(child.children) unless ALLOWED.include?(child.name)
+          unwrap(child) unless ALLOWED.include?(child.name)
         end
       end
       private_class_method :sanitize_children
+
+      # Replace an element with its own children (Nokogiri's
+      # Node#replace(children) has no single-node moxml counterpart).
+      def self.unwrap(child)
+        child.children.to_a.each { |c| child.add_previous_sibling(c) }
+        child.remove
+      end
+      private_class_method :unwrap
+
+      # Depth-first walk over node and all descendants.
+      def self.traverse(node, &block)
+        block.call(node)
+        node.children.to_a.each { |c| traverse(c, &block) }
+      end
+      private_class_method :traverse
     end
   end
 end

data/lib/relaton/bib.rb

@@ -19,6 +19,16 @@ require_relative "bib/model/bibdata"
 require_relative "bib/converter/bibxml"
 require_relative "bib/converter/bibtex"
 require_relative "bib/converter/asciibib"
+
+module Relaton
+  module Bib
+    module Converter
+      autoload :Ris, "relaton/bib/converter/ris"
+      autoload :Csl, "relaton/bib/converter/csl"
+      autoload :Titles, "relaton/bib/converter/titles"
+    end
+  end
+end
 require_relative "bib/model/relation"
 
 module Relaton

data/lib/relaton/bipm/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize
         @short = :relaton_bipm
         @prefix = "BIPM"
+        @pubid_identifier = :Bipm # Db cache key
         @defaultprefix = %r{^(?:BIPM|CCTF|CCDS|CGPM|CIPM|JCRB)(?!\w)}
         @idtype = "BIPM"
         @datasets = %w[bipm-data-outcomes bipm-si-brochure rawdata-bipm-metrologia]

data/lib/relaton/bipm/rawdata_bipm_metrologia/affiliations.rb

@@ -19,9 +19,9 @@ module Relaton::Bipm
       #
       def self.parse(dir)
         affiliations = Dir["#{dir}/*.xml"].each_with_object([]) do |path, m|
-          doc = Nokogiri::XML(File.read(path, encoding: "UTF-8"))
+          doc = Moxml.parse(File.read(path, encoding: "UTF-8"))
           doc.xpath("//aff").each do |aff|
-            m << parse_affiliation(aff) if aff.at("institution")
+            m << parse_affiliation(aff) if aff.at_xpath("institution")
           end
         end.uniq { |a| a.organization.name.first.content }
         new affiliations
@@ -31,18 +31,18 @@ module Relaton::Bipm
       # Parse affiliation organization
       # https://github.com/relaton/relaton-data-bipm/issues/17#issuecomment-1367035444
       #
-      # @param [Nokogiri::XML::Element] aff
+      # @param [Moxml::Element] aff
       #
       # @return [Relaton::Bib::Affiliation] Organization name, country, division, street address
       #
       def self.parse_affiliation(aff)
-        text = aff.at("text()").text
+        text = aff.at_xpath("text()").text
         return if text.include? "Permanent address:" || text.include?("1005 Southover Lane") ||
           text == "Germany" || text.starts_with?("Guest") || text.starts_with?("Deceased") ||
           text.include?("Author to whom any correspondence should be addressed")
 
         args = {}
-        institution = aff.at('institution')
+        institution = aff.at_xpath('institution')
         if institution
           name = institution.text
           return if name == "1005 Southover Lane"
@@ -72,7 +72,7 @@ module Relaton::Bipm
         address = []
         addr = aff.xpath("text()[preceding-sibling::institution]").text.gsub(/^\W*|\W*$/, "")
         address << addr unless addr.empty?
-        country = aff.at('country')
+        country = aff.at_xpath('country')
         address << country.text if country && !country.text.empty?
         address = address.join(", ")
         return [] if address.empty?

data/lib/relaton/bipm/si_brochure_parser.rb

@@ -1,4 +1,4 @@
-require "nokogiri"
+require "moxml"
 
 module Relaton::Bipm
   class SiBrochureParser
@@ -129,7 +129,7 @@ module Relaton::Bipm
     end
 
     def extract_editorialgroup(xml)
-      doc = Nokogiri::XML(xml)
+      doc = Moxml.parse(xml)
       doc.xpath("//editorialgroup/committee").map do |committee|
         acronym = committee["acronym"]
         names = committee.xpath("variant").map do |v|

data/lib/relaton/bsi/processor.rb

@@ -19,6 +19,11 @@ module Relaton::Bsi
       ::Relaton::Bsi::Bibliography.get(code, date, opts)
     end
 
+    # `Bibliography.get` applies a year to the document the reference names.
+    def fold_year(pubid, year)
+      fold_year_on_root pubid, year
+    end
+
     # @param xml [String]
     # @return [Relaton::Bsi::ItemData]
     def from_xml(xml)

data/lib/relaton/ccsds/bibliography.rb

@@ -46,6 +46,7 @@ module Relaton
         opts[:format] ||= Regexp.last_match(1)
         [ref, opts]
       end
+      public :parse_format
 
       def fetch_item(ref)
         hit = search(ref).first

data/lib/relaton/ccsds/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_ccsds
         @prefix = "CCSDS"
+        @pubid_identifier = :Ccsds # Db cache key
         @defaultprefix = %r{^CCSDS(?!\w)}
         @idtype = "CCSDS"
         @datasets = %w[ccsds]
@@ -22,6 +23,17 @@ module Relaton
         Bibliography.get(code, date, opts)
       end
 
+      # A format (` (DOC)` or `opts[:format]`) keeps only the item's sources
+      # of that format, a filter the Db cache cannot apply to a cached item:
+      # such a query gets no key, so it is not cached.
+      def cache_key(ref, year, opts)
+        require_relative "../ccsds"
+        _, format_opts = Bibliography.parse_format(ref, opts.dup)
+        return if format_opts[:format]
+
+        super
+      end
+
       #
       # Fetch all the documents from a source
       #

data/lib/relaton/cen/hit_collection.rb

@@ -105,7 +105,7 @@ module Relaton
       # @return [Array<RelatonCen::Hit>]
       def hits(resp)
         resp.xpath("//table[@class='dashlist']/tbody/tr/td[2]").map do |h|
-          ref = h.at("strong/a")
+          ref = h.at_xpath("strong/a")
           code = ref.text.strip
           url = ref[:href]
           Hit.new({ code: code, url: url }, self)

data/lib/relaton/cen/processor.rb

@@ -20,6 +20,11 @@ module Relaton
         ::Relaton::Cen::Bibliography.get(code, date, opts)
       end
 
+      # `Bibliography.get` applies a year to the document the reference names.
+      def fold_year(pubid, year)
+        fold_year_on_root pubid, year
+      end
+
       # @param xml [String]
       # @return [Relaton::Cen::ItemData]
       def from_xml(xml)