relaton-bib 1.4.0 → 2.1.7

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

@@ -0,0 +1,41 @@
+module Relaton
+  module Bib
+    class Relation < Lutaml::Model::Serializable
+      attribute :type, :string, values: %w[
+        includes includedIn hasPart partOf merges mergedInto splits splitInto
+        instanceOf hasInstance exemplarOf hasExemplar manifestationOf
+        hasManifestation reproductionOf hasReproduction reprintOf hasReprint
+        expressionOf hasExpression translatedFrom hasTranslation arrangementOf
+        hasArrangement abridgementOf hasAbridgement annotationOf hasAnnotation
+        draftOf hasDraft predecessorDraftOf hasPredecessorDraft successorDraftOf
+        hasSuccessorDraft editionOf hasEdition updates updatedBy derivedFrom
+        derives describes describedBy catalogues cataloguedBy hasSuccessor
+        successorOf adaptedFrom hasAdaptation adoptedFrom adoptedAs reviewOf
+        hasReview commentaryOf hasCommentary related hasComplement complementOf
+        obsoletes obsoletedBy cites isCitedIn
+      ]
+      attribute :description, LocalizedMarkedUpString
+      attribute :bibitem, ItemBase
+      choice(min: 1, max: 1) do
+        attribute :locality, Locality, collection: true, initialize_empty: true
+        attribute :locality_stack, LocalityStack, collection: true, initialize_empty: true
+      end
+      choice(min: 1, max: 1) do
+        attribute :source_locality, Locality, collection: true, initialize_empty: true
+        attribute :source_locality_stack, SourceLocalityStack, collection: true, initialize_empty: true
+      end
+
+      xml do
+        root "relation"
+
+        map_attribute "type", to: :type
+        map_element "description", to: :description
+        map_element "bibitem", to: :bibitem
+        map_element "locality", to: :locality
+        map_element "localityStack", to: :locality_stack
+        map_element "sourceLocality", to: :source_locality
+        map_element "sourceLocalityStack", to: :source_locality_stack
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Relaton
+  module Bib
+    class Series < Lutaml::Model::Serializable
+      attribute :type, :string, values: %w[main alt]
+      attribute :formattedref, Formattedref
+      attribute :title, Title, collection: (1..)
+      attribute :place, Place
+      attribute :organization, :string
+      attribute :abbreviation, LocalizedString
+      attribute :from, StringDate
+      attribute :to, StringDate
+      attribute :number, :string
+      attribute :partnumber, :string
+      attribute :run, :string
+
+      xml do
+        root "series"
+        map_attribute "type", to: :type
+        map_element "formattedref", to: :formattedref
+        map_element "title", to: :title
+        map_element "place", to: :place
+        map_element "organization", to: :organization
+        map_element "abbreviation", to: :abbreviation
+        map_element "from", to: :from
+        map_element "to", to: :to
+        map_element "number", to: :number
+        map_element "partnumber", to: :partnumber
+        map_element "run", to: :run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Relaton
+  module Bib
+    class Size < Lutaml::Model::Serializable
+      class Value < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :content, :string
+
+        xml do
+          root "value"
+          map_attribute "type", to: :type
+          map_content to: :content
+        end
+      end
+
+      attribute :value, Value, collection: (1..)
+
+      xml do
+        root "size"
+        map_element "value", to: :value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Relaton
+  module Bib
+    class SourceLocalityStack < Lutaml::Model::Serializable
+      attribute :connective, :string, values: %w[and or from to]
+      attribute :source_locality, Locality, collection: true, initialize_empty: true
+
+      xml do
+        root "sourceLocalityStack"
+        map_attribute "connective", to: :connective
+        map_element "sourceLocality", to: :source_locality
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Relaton
+  module Bib
+    class Status < Lutaml::Model::Serializable
+      class Stage < Lutaml::Model::Serializable
+        attribute :abbreviation, :string
+        attribute :content, :string
+
+        xml do
+          root "stage"
+          map_attribute "abbreviation", to: :abbreviation
+          map_content to: :content
+        end
+      end
+
+      attribute :stage, Stage
+      attribute :substage, Stage
+      attribute :iteration, :string
+
+      xml do
+        root "status"
+        map_element "stage", to: :stage
+        map_element "substage", to: :substage
+        map_element "iteration", to: :iteration
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Relaton
+  module Bib
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :agency, :string, collection: (1..)
+      attribute :klass, :string
+      attribute :docnumber, :string
+      attribute :partnumber, :string
+      attribute :edition, :string
+      attribute :version, :string
+      attribute :supplementtype, :string
+      attribute :supplementnumber, :string
+      attribute :amendment, :string
+      attribute :corrigendum, :string
+      attribute :language, :string
+      attribute :year, :string
+
+      xml do
+        root "structuredidentifier"
+        map_attribute "type", to: :type
+        map_element "agency", to: :agency
+        map_element "class", to: :klass
+        map_element "docnumber", to: :docnumber
+        map_element "partnumber", to: :partnumber
+        map_element "edition", to: :edition
+        map_element "version", to: :version
+        map_element "supplementtype", to: :supplementtype
+        map_element "supplementnumber", to: :supplementnumber
+        map_element "amendment", to: :amendment
+        map_element "corrigendum", to: :corrigendum
+        map_element "language", to: :language
+        map_element "year", to: :year
+      end
+
+      def remove_part!
+        raise NotImplementedError, "`remove_part!` method not implemented in #{self.class}"
+      end
+
+      def to_all_parts!
+        raise NotImplementedError, "`to_all_parts!` method not implemented in #{self.class}"
+      end
+
+      def remove_date!
+        raise NotImplementedError, "`remove_date!` method not implemented in #{self.class}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Subdivision < Lutaml::Model::Serializable
+      include OrganizationType
+
+      attribute :type, :string
+      attribute :subtype, :string
+
+      xml do
+        root "subdivision"
+        map_attribute "type", to: :type
+        map_attribute "subtype", to: :subtype
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Relaton
+  module Bib
+    class Title < LocalizedMarkedUpString
+      attribute :type, :string
+      attribute :format, :string # @DEPRECATED
+
+      xml do
+        map_attribute "type", to: :type
+        map_attribute "format", to: :format
+      end
+
+      key_value do
+        map "type", to: :type
+        map "format", to: :format
+      end
+
+      class << self
+        def from_string(title, lang = nil, script = nil)
+          types = %w[title-intro title-main title-part]
+          ttls = split_title(title)
+          tts = ttls.map.with_index do |p, i|
+            next unless p
+
+            new type: types[i], content: p, language: lang, script: script
+          end.compact
+          tts << new(type: "main", content: ttls.compact.join(" - "), language: lang, script: script)
+          tts
+        end
+
+        private
+
+        # @param title [String]
+        # @return [Array<String, nil>]
+        def split_title(title)
+          ttls = title.sub(/\w\.Imp\s?\d+\u00A0:\u00A0/, "").split " - "
+          case ttls.size
+          when 0, 1 then [nil, ttls.first.to_s, nil]
+          else intro_or_part ttls
+          end
+        end
+
+        # @param ttls [Array<String>]
+        # @return [Array<String, nil>]
+        def intro_or_part(ttls)
+          if /^(Part|Partie) \d+:/.match? ttls[1]
+            [nil, ttls[0], ttls[1..].join(" -- ")]
+          else
+            parts = ttls.slice(2..-1)
+            part = parts.join " -- " if parts.any?
+            [ttls[0], ttls[1], part]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/type/plain_date.rb

@@ -0,0 +1,16 @@
+require "date"
+
+module Relaton
+  module Bib
+    # xs:date value type that always casts to ::Date, dropping any time and
+    # timezone component. Without this, lutaml-model's built-in Date type
+    # promotes inputs like "2018-04-15T00:00:00Z" to ::DateTime and serializes
+    # them back as "2018-04-15Z" — valid xs:date, but not valid ISO 8601.
+    class PlainDate < Lutaml::Model::Type::Date
+      def self.cast(value, options = {})
+        result = super
+        result.is_a?(::DateTime) ? result.to_date : result
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/type/string_date.rb

@@ -0,0 +1,48 @@
+require "forwardable"
+
+module Relaton
+  module Bib
+    class StringDate < Lutaml::Model::Type::Value
+      class Value
+        include Comparable
+        extend Forwardable
+        extend Core::DateParser
+        include Core::DateParser
+
+        def_delegators :@value, :split, :to_s
+
+        def initialize(value)
+          @value = value
+        end
+
+        def self.parse_date(date)
+          value = super
+          new value if value
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(Value)
+
+          @value <=> other.to_s
+        end
+
+        def to_date
+          parse_date(@value, str: false)
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      def self.cast(value)
+        case value
+        when Value then value
+        when String then Value.parse_date(value)
+        end
+      end
+
+      def to_yaml
+        value.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    class Uri < LocalizedStringAttrs
+      attribute :type, :string
+      attribute :content, :string
+
+      xml do
+        map_attribute "type", to: :type
+        map_content to: :content
+      end
+
+      key_value do
+        map "type", to: :type
+        map "content", to: :content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Validity < Lutaml::Model::Serializable
+      attribute :begins, :date_time
+      attribute :ends, :date_time
+      attribute :revision, :date_time
+
+      xml do
+        root "validity"
+        map_element "validityBegins", to: :begins
+        map_element "validityEnds", to: :ends
+        map_element "revision", to: :revision
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Relaton
+  module Bib
+    class Version < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :content, :string
+      attribute :revision_date, :string
+      attribute :draft, :string
+
+      xml do
+        root "version"
+        map_attribute "type", to: :type
+        map_content to: :content
+        map_element "revision-date", to: :revision_date
+        map_element "draft", to: :draft
+      end
+
+      key_value do
+        map "type", to: :type
+        map "content", to: :content
+        map "revision_date", to: :revision_date
+        map "draft", to: :draft
+      end
+
+      def content
+        return @content if @content && !@content.empty?
+
+        parts = [@draft, @revision_date].compact
+        case parts.size
+        when 2 then "#{@draft} (#{@revision_date})"
+        when 1 then parts.first
+        end
+      end
+
+      def revision_date
+        nil
+      end
+
+      def draft
+        nil
+      end
+    end
+  end
+end

data/lib/relaton/bib/model_autoload.rb

@@ -0,0 +1,85 @@
+# Central autoload manifest for the model + converter layer.
+#
+# Declaring these as autoloads (instead of a require_relative chain) makes load
+# order irrelevant and removes the circular require between OrganizationType and
+# Subdivision (issue #120): a constant is loaded on first reference rather than
+# at file-load time, so mutually-referencing classes resolve each other lazily.
+#
+# lutaml-model must be available before the first model autoload fires, and the
+# XML adapter must be configured eagerly here (not inside item.rb) so that
+# serializing through any model class works regardless of which one is
+# referenced first.
+require "lutaml/model"
+require "lutaml/xml"
+
+Lutaml::Model::Config.configure do |config|
+  config.xml_adapter_type = :nokogiri
+end
+
+module Relaton
+  module Bib
+    autoload :Abstract, "relaton/bib/model/abstract"
+    autoload :Address, "relaton/bib/model/address"
+    autoload :Affiliation, "relaton/bib/model/affiliation"
+    autoload :Bibdata, "relaton/bib/model/bibdata"
+    autoload :BibdataShared, "relaton/bib/model/bibdata_shared"
+    autoload :Bibitem, "relaton/bib/model/bibitem"
+    autoload :BibitemShared, "relaton/bib/model/bibitem_shared"
+    autoload :Contact, "relaton/bib/model/contact"
+    autoload :ContributionInfo, "relaton/bib/model/contribution_info"
+    autoload :Contributor, "relaton/bib/model/contributor"
+    autoload :Copyright, "relaton/bib/model/copyright"
+    autoload :Date, "relaton/bib/model/date"
+    autoload :Depiction, "relaton/bib/model/depiction"
+    autoload :Docidentifier, "relaton/bib/model/docidentifier"
+    autoload :Doctype, "relaton/bib/model/doctype"
+    autoload :Edition, "relaton/bib/model/edition"
+    autoload :Ext, "relaton/bib/model/ext"
+    autoload :Extent, "relaton/bib/model/extent"
+    autoload :Formattedref, "relaton/bib/model/formattedref"
+    autoload :FullName, "relaton/bib/model/fullname"
+    autoload :FullNameType, "relaton/bib/model/full_name_type"
+    autoload :ICS, "relaton/bib/model/ics"
+    autoload :Image, "relaton/bib/model/image"
+    autoload :Item, "relaton/bib/model/item"
+    autoload :ItemBase, "relaton/bib/model/item_base"
+    autoload :ItemShared, "relaton/bib/model/item_shared"
+    autoload :Keyword, "relaton/bib/model/keyword"
+    autoload :Locality, "relaton/bib/model/locality"
+    autoload :LocalityStack, "relaton/bib/model/locality_stack"
+    # localized_string.rb defines three top-level constants:
+    autoload :LocalizedString, "relaton/bib/model/localized_string"
+    autoload :TypedLocalizedString, "relaton/bib/model/localized_string"
+    autoload :LocalizedMarkedUpString, "relaton/bib/model/localized_string"
+    autoload :LocalizedStringAttrs, "relaton/bib/model/localized_string_attrs"
+    autoload :Logo, "relaton/bib/model/logo"
+    autoload :Medium, "relaton/bib/model/medium"
+    autoload :Note, "relaton/bib/model/note"
+    autoload :Organization, "relaton/bib/model/organization"
+    autoload :OrganizationType, "relaton/bib/model/organization_type"
+    autoload :Person, "relaton/bib/model/person"
+    autoload :Phone, "relaton/bib/model/phone"
+    autoload :Place, "relaton/bib/model/place"
+    # type/ is only a directory; these constants are top-level under Bib:
+    autoload :PlainDate, "relaton/bib/model/type/plain_date"
+    autoload :StringDate, "relaton/bib/model/type/string_date"
+    autoload :Price, "relaton/bib/model/price"
+    autoload :Relation, "relaton/bib/model/relation"
+    autoload :Series, "relaton/bib/model/series"
+    autoload :Size, "relaton/bib/model/size"
+    autoload :SourceLocalityStack, "relaton/bib/model/source_locality_stack"
+    autoload :Status, "relaton/bib/model/status"
+    autoload :StructuredIdentifier, "relaton/bib/model/structured_identifier"
+    autoload :Subdivision, "relaton/bib/model/subdivision"
+    autoload :Title, "relaton/bib/model/title"
+    autoload :Uri, "relaton/bib/model/uri"
+    autoload :Validity, "relaton/bib/model/validity"
+    autoload :Version, "relaton/bib/model/version"
+
+    module Converter
+      autoload :BibXml, "relaton/bib/converter/bibxml"
+      autoload :Bibtex, "relaton/bib/converter/bibtex"
+      autoload :Asciibib, "relaton/bib/converter/asciibib"
+    end
+  end
+end

data/lib/relaton/bib/namespace_helper.rb

@@ -0,0 +1,21 @@
+module Relaton
+  module Bib
+    module NamespaceHelper
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def namespace
+          @namespace = Object.const_get name.split("::")[0..1].join("::")
+        end
+      end
+
+      private
+
+      def namespace
+        self.class.namespace
+      end
+    end
+  end
+end

data/lib/relaton/bib/sanitizer.rb

@@ -0,0 +1,74 @@
+require "nokogiri"
+
+module Relaton
+  module Bib
+    # Strips inline markup not in the basicdoc PureTextElement set
+    # (plus <p>, <eref>, <xref>, <fn>, <link>) from raw marked-up content
+    # strings. Disallowed elements are unwrapped: tags removed, inner text
+    # kept.
+    #
+    # <link> is admitted because basicdoc expresses external hyperlinks as
+    # <link target="...">; without it a from_xml -> to_xml round-trip drops
+    # the tag and its target URL, keeping only the link text (see #122,
+    # which broke metanorma amend()).
+    #
+    # <fn> is admitted beyond strict PureTextElement because bibliographic
+    # titles in real Metanorma input routinely carry footnotes (e.g. ISO
+    # standards titles with a disclaimer footnote), and downstream
+    # consumers — notably relaton-render's own inline-tag allow-list —
+    # already accept <fn> as a legitimate child of <title>. Stripping it
+    # here would break the round-trip.
+    #
+    # OPAQUE elements (currently <stem>) are also allowed, but the
+    # sanitiser does not descend into them: their contents are out-of-band
+    # inline notation (MathML, AsciiMath, LaTeX) rather than basicdoc
+    # 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.
+    module Sanitizer
+      ALLOWED = %w[
+        em strong sub sup tt underline strike smallcap br stem
+        p eref xref fn link
+      ].freeze
+
+      # Elements whose children are non-basicdoc inline notation
+      # (MathML, AsciiMath, LaTeX, …) and must be preserved verbatim
+      # rather than sanitised against ALLOWED.
+      OPAQUE = %w[stem].freeze
+
+      RENAME = {
+        "italic" => "em",
+      }.freeze
+
+      TAG_RX = %r{<[a-zA-Z/!?]}
+
+      def self.sanitize(content)
+        return content unless sanitizable?(content)
+
+        fragment = Nokogiri::XML::DocumentFragment.parse(content)
+        return content if fragment.errors.any?
+
+        sanitize_children(fragment)
+        fragment.children.map { |c| c.to_xml(encoding: "UTF-8") }.join
+      end
+
+      def self.sanitizable?(content)
+        content.is_a?(::String) && !content.empty? && content.match?(TAG_RX)
+      end
+      private_class_method :sanitizable?
+
+      def self.sanitize_children(node)
+        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)
+          child.replace(child.children) unless ALLOWED.include?(child.name)
+        end
+      end
+      private_class_method :sanitize_children
+    end
+  end
+end

data/lib/relaton/bib/util.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    module Util
+      extend self
+
+      PROGNAME = "relaton-bib".freeze
+
+      def method_missing(method_name, msg = nil, prog = nil, **opts, &block)
+        prog ||= self::PROGNAME
+        Relaton.logger_pool.send method_name, msg, prog, **opts, &block
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        Relaton.logger_pool.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/relaton/bib/version.rb

@@ -0,0 +1,5 @@
+module Relaton
+  module Bib
+    VERSION = "2.1.7".freeze
+  end
+end

data/lib/relaton/bib/versions.json

@@ -0,0 +1,35 @@
+{
+"relaton-models": "v1.5.6",
+"basicdoc-models": "v1.2.5",
+"metanorma-requirements-models": "v1.0.2",
+"relaton-model-ieee": "v1.1.3",
+"relaton-model-iso": "v1.1.2",
+"relaton-model-iec": "v1.1.2",
+"relaton-model-bsi": "v1.1.3",
+"relaton-model-gb": "v1.1.2",
+"relaton-model-mpfa": "v1.0.0",
+"relaton-model-bipm": "v1.1.2",
+"relaton-model-w3c": "v1.0.0",
+"relaton-model-3gpp": "v1.0.4",
+"relaton-model-cc": "v1.1.2",
+"relaton-model-ietf": "v1.1.2",
+"relaton-model-iho": "v1.1.2",
+"relaton-model-itu": "v1.1.3",
+"relaton-model-m3aawg": "v1.0.1",
+"relaton-model-nist": "v1.1.2",
+"relaton-model-ribose": "v1.1.2",
+"relaton-model-ogc": "v1.1.2",
+"relaton-model-cen": "v1.0.1",
+"relaton-model-ecma": "v1.0.0",
+"relaton-model-cie": "v1.0.0",
+"relaton-model-iana": "v1.0.0",
+"relaton-model-omg": "v1.0.0",
+"relaton-model-oasis": "v1.0.4",
+"relaton-model-jis": "v1.0.2",
+"relaton-model-etsi": "v0.1.2",
+"relaton-model-plateau": "v0.1.0",
+"relaton-model-ccsds": "",
+"relaton-model-un": "v1.0.2",
+"metanorma-model": "v2.1.6",
+"date": "2026-04-30T03:49:24Z"
+}