relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/adobe/ext.rb

@@ -0,0 +1,32 @@
+module Relaton
+  module Adobe
+    # Adobe bibliographic item extension. Adds Adobe-specific structured
+    # metadata on top of the shared Relaton::Bib::Ext so the fields
+    # round-trip through both XML and YAML without per-repo merge hacks.
+    # Doctype is referenced lazily via autoload from lib/relaton/adobe.rb.
+    class Ext < Bib::Ext
+      attribute :doctype,           Doctype
+      attribute :urn,               :string
+      attribute :webpage,           :string
+      attribute :tech_note_number,  :string
+      attribute :source_repo_path,  :string
+      attribute :publication_slug,  :string
+
+      xml do
+        map_element "urn",               to: :urn
+        map_element "webpage",           to: :webpage
+        map_element "tech_note_number",  to: :tech_note_number
+        map_element "source_repo_path",  to: :source_repo_path
+        map_element "publication_slug",  to: :publication_slug
+      end
+
+      key_value do
+        map_element "urn",               to: :urn
+        map_element "webpage",           to: :webpage
+        map_element "tech_note_number",  to: :tech_note_number
+        map_element "source_repo_path",  to: :source_repo_path
+        map_element "publication_slug",  to: :publication_slug
+      end
+    end
+  end
+end

data/lib/relaton/adobe/item.rb

@@ -0,0 +1,15 @@
+module Relaton
+  module Adobe
+    # Adobe bibliographic item. Re-declares +ext+ to use the typed Ext
+    # subclass so Adobe-specific fields round-trip natively. Sub-files
+    # (ItemData, Ext, Docidentifier) are loaded lazily via the autoload
+    # entries declared in lib/relaton/adobe.rb.
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
+    end
+  end
+end

data/lib/relaton/adobe/item_base.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Adobe
+    class ItemBase < Lutaml::Model::Serializable
+      include Bib::NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&Bib::ItemShared::ATTRIBUTES)
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&Bib::ItemShared::XML_BODY)
+      end
+    end
+  end
+end

data/lib/relaton/adobe/item_data.rb

@@ -0,0 +1,6 @@
+module Relaton
+  module Adobe
+    class ItemData < Bib::ItemData
+    end
+  end
+end

data/lib/relaton/adobe/processor.rb

@@ -0,0 +1,45 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Adobe
+    # Relaton processor for the Adobe flavor. Registered by
+    # Relaton::Registry when the unified gem loads (see
+    # lib/relaton/registry.rb). Supports `relaton fetch adobe ...` once
+    # the relaton-data-adobe dataset is installed.
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_adobe
+        @prefix = "Adobe"
+        @defaultprefix = %r{^(?:Adobe|ATN)}
+        @idtype = "Adobe"
+      end
+
+      def get(code, date, opts)
+        require_relative "../adobe"
+        Bibliography.get(code, date, opts)
+      end
+
+      def from_xml(xml)
+        require_relative "../adobe"
+        Item.from_xml xml
+      end
+
+      def from_yaml(yaml)
+        require_relative "../adobe"
+        Item.from_yaml(yaml)
+      end
+
+      def grammar_hash
+        require_relative "../adobe"
+        @grammar_hash ||= ::Relaton::Adobe.grammar_hash
+      end
+
+      def remove_index_file
+        require_relative "../adobe"
+        Relaton::Index.find_or_create(:adobe, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/adobe/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Adobe
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-adobe".freeze
+    end
+  end
+end

data/lib/relaton/adobe.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "relaton/bib"
+require "relaton/index"
+require "pubid"
+require "relaton/version"
+
+# Relaton::Adobe is the Adobe (font tech notes, character collections,
+# PostScript Language, etc.) flavor of the unified relaton gem. Adds
+# typed Ext fields (urn, webpage, tech_note_number, source_repo_path,
+# publication_slug) so they round-trip natively through YAML and XML
+# without per-repo merge hacks.
+module Relaton
+  module Adobe
+    INDEXFILE = "index-v2".freeze
+
+    class Error < StandardError; end
+
+    autoload :Doctype,       "relaton/adobe/doctype"
+    autoload :Ext,           "relaton/adobe/ext"
+    autoload :ItemData,      "relaton/adobe/item_data"
+    autoload :ItemBase,      "relaton/adobe/item_base"
+    autoload :Item,          "relaton/adobe/item"
+    autoload :Bibitem,       "relaton/adobe/bibitem"
+    autoload :Bibdata,       "relaton/adobe/bibdata"
+    autoload :Docidentifier, "relaton/adobe/docidentifier"
+    autoload :Util,          "relaton/adobe/util"
+    autoload :Bibliography,  "relaton/adobe/bibliography"
+    autoload :Processor,     "relaton/adobe/processor"
+
+    # Returns hash of XML grammar
+    # @return [String]
+    def self.grammar_hash
+      Digest::MD5.hexdigest Relaton::VERSION
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Relaton
       attribute :state, :string
       attribute :country, :string
       attribute :postcode, :string
-      attribute :formatted_address, :string, raw: true
+      attribute :formatted_address, :string
 
       xml do
         root "address"
@@ -15,7 +15,7 @@ module Relaton
         map_element "state", to: :state
         map_element "country", to: :country
         map_element "postcode", to: :postcode
-        map_element "formattedAddress", to: :formatted_address
+        map_element "formattedAddress", to: :formatted_address, raw: :content
       end
     end
   end

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

@@ -18,17 +18,32 @@ module Relaton
         map "primary", to: :primary
       end
 
-      def remove_part!
-        raise NotImplementedError, "`remove_part!` method not implemented in #{self.class}"
-      end
+      # `Bib::ItemData#to_all_parts` and `#to_most_recent_reference` broadcast
+      # these three to EVERY docidentifier unconditionally, so raising here made
+      # both calls unusable for any flavor that had not subclassed this class —
+      # 13 of them had not, and both died on every item they produced. The raise
+      # was also `NotImplementedError`, which descends from `ScriptError`, so a
+      # caller's `rescue => e` did not even catch it.
+      #
+      # The default is therefore a **no-op**. An identifier that models neither
+      # a part nor a date has nothing to strip, and returning it unchanged is
+      # the correct answer for both calls.
+      #
+      # A flavor whose identifier does carry one overrides these — see
+      # `Relaton::Ogc::Docidentifier` or `Relaton::Iala::Docidentifier` for the
+      # pubid-backed shape (parse `content` into a pubid, mutate, re-render
+      # through a `store_content` alias so the write does not re-parse).
+      #
+      # The trade-off, recorded so it stays a choice rather than an oversight: a
+      # flavor that DOES carry a date but has not overridden `remove_date!` now
+      # returns a dated reference silently, where before it crashed loudly.
+      # That is a missing override in the flavor, not a defect here.
 
-      def to_all_parts!
-        raise NotImplementedError, "`to_all_parts!` method not implemented in #{self.class}"
-      end
+      def remove_part!; end
 
-      def remove_date!
-        raise NotImplementedError, "`remove_date!` method not implemented in #{self.class}"
-      end
+      def to_all_parts!; end
+
+      def remove_date!; end
     end
   end
 end

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

@@ -32,7 +32,7 @@ module Relaton
         end
       end
 
-      attribute :content, :string, raw: true
+      attribute :content, :string
       prepend ContentSanitization
 
       xml do

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

@@ -32,17 +32,18 @@ module Relaton
         map_element "year", to: :year
       end
 
-      def remove_part!
-        raise NotImplementedError, "`remove_part!` method not implemented in #{self.class}"
-      end
+      # The same broadcast reaches `ext.structuredidentifier`
+      # (`Bib::ItemData#ext_to_all_parts!` / `#ext_remove_date`), so these
+      # default to no-ops for the same reason as `Bib::Docidentifier`'s: a
+      # structured identifier with no part and no date has nothing to strip.
+      # Flavors that model one override them — see
+      # `Relaton::Iso::StructuredIdentifier` and `Relaton::Gb::StructuredIdentifier`.
 
-      def to_all_parts!
-        raise NotImplementedError, "`to_all_parts!` method not implemented in #{self.class}"
-      end
+      def remove_part!; end
 
-      def remove_date!
-        raise NotImplementedError, "`remove_date!` method not implemented in #{self.class}"
-      end
+      def to_all_parts!; end
+
+      def remove_date!; end
     end
   end
 end

data/lib/relaton/bib/sanitizer.rb

@@ -3,8 +3,13 @@ require "nokogiri"
 module Relaton
   module Bib
     # Strips inline markup not in the basicdoc PureTextElement set
-    # (plus <p>, <eref>, <xref>, <fn>) from raw marked-up content strings.
-    # Disallowed elements are unwrapped: tags removed, inner text kept.
+    # (plus <p>, <eref>, <xref>, <fn>, <link>) from raw marked-up content
+    # strings. Disallowed elements are unwrapped: tags removed, inner text kept.
+    #
+    # <link> (basicdoc's inline hyperlink) is admitted because it is a valid
+    # TextElement child of a biblionote and carries a target URL that must
+    # survive the from_xml/to_xml round-trip — dropping it silently loses
+    # every URL in amended note.display references (relaton-bib#122).
     #
     # <fn> is admitted beyond strict PureTextElement because bibliographic
     # titles in real Metanorma input routinely carry footnotes (e.g. ISO
@@ -22,7 +27,7 @@ module Relaton
     module Sanitizer
       ALLOWED = %w[
         em strong sub sup tt underline strike smallcap br stem
-        p eref xref fn
+        p eref xref fn link
       ].freeze
 
       # Elements whose children are non-basicdoc inline notation
@@ -36,15 +41,206 @@ module Relaton
 
       TAG_RX = %r{<[a-zA-Z/!?]}
 
+      # Captures a namespace prefix, on a tag or on an attribute: the
+      # "jats" of <jats:p> and </jats:italic>, and the "xlink" of
+      # xlink:href.
+      NS_PREFIX_RX = %r{(?:</?|\s)([A-Za-z_][\w.-]*):(?=[A-Za-z_])}
+
+      # Namespace that declares a prefix which the content leaves
+      # undeclared. The sanitiser removes it again before it serialises.
+      NS_PLACEHOLDER = "urn:x-relaton-undeclared:%s".freeze
+
+      # Element that carries the placeholder declarations. Its children
+      # are the sanitised content, so the element itself never reaches
+      # the output.
+      NS_WRAPPER = "relaton-sanitizer-root".freeze
+
+      # Extension that lengthens the wrapper name past a collision, and
+      # the pattern that measures how far the content already extends it.
+      NS_WRAPPER_SUFFIX = "-x".freeze
+      NS_WRAPPER_RX = /#{NS_WRAPPER}(?:#{NS_WRAPPER_SUFFIX})*/
+
+      # 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)
 
+        node = parse(content)
+        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
+      end
+
+      #
+      # Parse the content into a node whose children are the content.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [Nokogiri::XML::Node, nil] The node, or nil when the
+      #   content does not parse.
+      #
+      def self.parse(content)
         fragment = Nokogiri::XML::DocumentFragment.parse(content)
-        return content if fragment.errors.any?
+        return fragment if fragment.errors.empty?
+
+        parse_with_prefixes(content)
+      end
+      private_class_method :parse
+
+      #
+      # Parse content that uses undeclared namespace prefixes.
+      #
+      # An undeclared prefix is always a parse error, so without this the
+      # sanitiser gives up on exactly the third-party markup that needs
+      # sanitising most. Declare every prefix that the content uses on a
+      # wrapper element, parse, then remove the placeholder namespaces
+      # from the elements and from the attributes. See metanorma-pdfa#99.
+      #
+      # An undeclared prefix inside an OPAQUE <stem> goes as well. The
+      # sanitiser cannot keep it: an undeclared prefix in the output is
+      # the exact failure that this method removes. Only a namespace that
+      # the content declares itself survives verbatim.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [Nokogiri::XML::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?
+
+        drop_placeholder_namespaces doc.root
+      end
+      private_class_method :parse_with_prefixes
+
+      #
+      # Declare every namespace prefix that the content uses.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [String, nil] The declarations, or nil when the content
+      #   uses no prefix.
+      #
+      def self.placeholder_declarations(content)
+        prefixes = content.scan(NS_PREFIX_RX).flatten.uniq - NS_RESERVED
+        return if prefixes.empty?
+
+        prefixes.map do |pfx|
+          %(xmlns:#{pfx}="#{format NS_PLACEHOLDER, pfx}")
+        end.join(" ")
+      end
+      private_class_method :placeholder_declarations
+
+      #
+      # Name a wrapper element that the content does not close itself.
+      #
+      # Content that holds the literal end tag of the wrapper would close
+      # it early. The document then has more than one root, the parse
+      # fails, and the sanitiser gives up on content that it can handle.
+      #
+      # Extend past the longest run of the suffix that the content already
+      # holds, in ONE scan. Growing the name and re-testing with include?
+      # is quadratic: each extension re-scans the whole string, and
+      # content shaped like "…-root-x-x-x" forces one pass per two
+      # characters (measured at 229 ms for 20k characters). The sanitiser
+      # runs on every marked-up assignment, on third-party content.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [String] A name that the content does not contain.
+      #
+      def self.wrapper_name(content)
+        longest = content.scan(NS_WRAPPER_RX).map(&:size).max
+        return NS_WRAPPER unless longest
+
+        extra = ((longest - NS_WRAPPER.size) / NS_WRAPPER_SUFFIX.size) + 1
+        NS_WRAPPER + (NS_WRAPPER_SUFFIX * extra)
+      end
+      private_class_method :wrapper_name
+
+      #
+      # Remove the placeholder namespaces, and only those.
+      #
+      # Nokogiri's remove_namespaces! would also strip a namespace that
+      # the content declares itself, such as the MathML xmlns inside an
+      # OPAQUE <stem>, which must survive verbatim. Match the wrapper's
+      # own declarations, so a namespace of the content never matches,
+      # whatever its URI.
+      #
+      # The declarations stay on the wrapper element. Only its children
+      # reach the output, so the declarations never leak. Do not
+      # serialise the root itself.
+      #
+      # @param [Nokogiri::XML::Element] root The wrapper element.
+      #
+      # @return [Nokogiri::XML::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)
+          next unless node.element?
+
+          drop_attribute_namespaces node, placeholders
+        end
+        root
+      end
+      private_class_method :drop_placeholder_namespaces
+
+      #
+      # Un-prefix the placeholder attributes of one element.
+      #
+      # Un-prefixing renames the attribute, so it can collide: an element
+      # carrying both target and xlink:target would keep two attributes
+      # called target, and Nokogiri rejects the result with "Attribute
+      # 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.
+      #
+      # @return [void]
+      #
+      def self.drop_attribute_namespaces(node, placeholders)
+        node.attribute_nodes.each do |attr|
+          next unless placeholders.include?(attr.namespace)
+
+          if plain_attribute?(node, attr.name) then attr.unlink
+          else attr.namespace = nil
+          end
+        end
+      end
+      private_class_method :drop_attribute_namespaces
 
-        sanitize_children(fragment)
-        fragment.children.map { |c| c.to_xml(encoding: "UTF-8") }.join
+      #
+      # Does the element already carry this attribute without a prefix?
+      #
+      # Nokogiri's Node#attribute matches on the name alone, so it finds
+      # 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 [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 }
       end
+      private_class_method :plain_attribute?
 
       def self.sanitizable?(content)
         content.is_a?(::String) && !content.empty? && content.match?(TAG_RX)

data/lib/relaton/bib.rb

@@ -24,8 +24,6 @@ require_relative "bib/model/relation"
 module Relaton
   # class Error < StandardError; end
 
-  class RequestError < StandardError; end
-
   class << self
     #
     # Read schema versions from file