relaton 3.0.0.pre.alpha.4 → 3.0.0.pre.alpha.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2c4c35d668277f91fb1ad11eafe4da0b25f49fe9110ac81df83d8bae5bebcac
-  data.tar.gz: 6d0e6ce6134990d786cb67fc20c1a90a1992ced44907191e03340f3a34702c0c
+  metadata.gz: 5029468b22fa9cc5e65bf7d76f8bb6db597fb331bc1f0a89a21186063ea49963
+  data.tar.gz: 6e572768f9ae838d04e682eb6e5cbc2a48dcb9e999fd2f4dce588952072475a6
 SHA512:
-  metadata.gz: dff41b1c067bc5eb8a5737b1fa6dc927dc9ef0d0b04a8e33a7bc4d637c6c78a99bbb8f4ec7cd3aeee5682cab61f099b4d15952884b990da8020db6fe9122df0d
-  data.tar.gz: 77c8b1aba1fb16829882b3e311416db6e2481d3800c898148810203d0805a4bd0caef2960831a464b44f9e357aff1cdad6cc9573dc02473518179621acf7f1b0
+  metadata.gz: 9ef70c48d70df0a8d7105b7195e0124f51a501eab815bca1ce6825a9113d338f3a1203c237d896443ae0f5ed1893efef97719bfd9a2938c53b58155171bf6c46
+  data.tar.gz: bb362dea5df12c9021b0725132e4f365aa8f97d6a81e9b41c2190c66121b6948aa4f6aee9a52f0c51e218ea38b5655b6ad014ea97d8100f00a83d07098ebfa0c

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

@@ -6,15 +6,17 @@ module Relaton
     module Bibliography
       SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-3gpp/v2/"
 
-      # @param text [String]
+      # @param ref [String, ::Pubid::Tgpp::Identifier] the reference, or the
+      #   parse that Relaton::Db routed with (relaton#205)
       # @return [Relaton::ThreeGpp::ItemData, nil]
-      def search(text)
+      def search(ref)
         # An unrecognized reference raises; like ISO and ETSI we let it
         # propagate — relaton-cli rescues Pubid::Errors::Error and renders
         # "… is not a recognized standards identifier", and API callers rescue
         # it themselves. The rescue below lists transport errors only, so it
         # does not swallow the parse error.
-        pubid = ::Pubid::Tgpp::Identifier.parse text.to_s.strip
+        pubid = ref
+        pubid = ::Pubid::Tgpp::Identifier.parse ref.strip if ref.is_a?(String)
         row = best_match pubid
         return unless row
 
@@ -36,19 +38,30 @@ module Relaton
       # @param opts [Hash] options
       # @return [Relaton::ThreeGpp::ItemData, nil]
       def get(ref, _year = nil, _opts = {})
-        Util.info "Fetching from Relaton repository ...", key: ref
+        Util.info "Fetching from Relaton repository ...", key: log_key(ref)
         result = search(ref)
         unless result
-          Util.info "Not found.", key: ref
+          Util.info "Not found.", key: log_key(ref)
           return
         end
 
-        Util.info "Found: `#{result.docidentifier[0].content}`", key: ref
+        Util.info "Found: `#{result.docidentifier[0].content}`",
+                  key: log_key(ref)
         result
       end
 
       private
 
+      # `Pubid::Tgpp#to_s` omits the `3GPP ` publisher token by default (it
+      # renders the index id), so a pubid from Relaton::Db (relaton#205) is
+      # logged with it, as the caller wrote the reference.
+      #
+      # @param ref [String, ::Pubid::Tgpp::Identifier]
+      # @return [String]
+      def log_key(ref)
+        ref.is_a?(String) ? ref : ref.to_s(with_publisher: true)
+      end
+
       #
       # Find the index row for a reference, newest version first.
       #

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

@@ -23,6 +23,12 @@ module Relaton
         Bibliography.get(code, date, opts)
       end
 
+      # 3GPP index ids print without the `3GPP ` token
+      # (`TS 23.207:REL-18/18.0.0`).
+      def bare_identifiers?
+        true
+      end
+
       #
       # Fetch all the documents from http://xml2rfc.tools.ietf.org/public/rfc/bibxml-3gpp-new/
       #

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,29 @@ 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
+
+      # ISO 690 rendered reference (the style instance lives in the
+      # relaton-models citation module; the engine in relaton-render).
+      def to_iso690(lang: "en", script: "Latn")
+        require "relaton/render/iso690"
+        Render::Iso690::Renderer.render(self, lang: lang, script: script)
+      end
+
+      # ISO 690 name-and-date in-text citation.
+      def to_iso690_citation(lang: "en", script: "Latn", disambiguator: nil)
+        require "relaton/render/iso690"
+        Render::Iso690::Renderer.citation(
+          self, disambiguator: disambiguator, lang: lang, script: script
+        )
+      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