relaton 2.1.0 → 3.0.0.pre.alpha.1

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

@@ -0,0 +1,33 @@
+module Relaton
+  module Bib
+    class Place < Lutaml::Model::Serializable
+      class RegionType < Lutaml::Model::Serializable
+        attribute :iso, :string
+        attribute :recommended, :boolean
+        attribute :content, :string
+
+        xml do
+          root "region"
+          map_attribute "iso", to: :iso
+          map_attribute "recommended", to: :recommended
+          map_content to: :content
+        end
+      end
+
+      attribute :city, :string
+      attribute :region, RegionType, collection: true, initialize_empty: true
+      attribute :country, RegionType, collection: true, initialize_empty: true
+      attribute :formatted_place, :string
+      attribute :uri, Uri
+
+      xml do
+        root "place"
+        map_element "city", to: :city
+        map_element "region", to: :region
+        map_element "country", to: :country
+        map_element "formattedPlace", to: :formatted_place
+        map_element "uri", to: :uri
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Relaton
+  module Bib
+    class Price < Lutaml::Model::Serializable
+      attribute :currency, :string
+      attribute :content, :string
+
+      xml do
+        root "price"
+        map_attribute "currency", to: :currency
+        map_content to: :content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative "item_base"
+
+module Relaton
+  module Bib
+    class Relation
+      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,34 @@
+require_relative "type/string_date"
+
+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/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,68 @@
+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.
+    #
+    # <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
+      ].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/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"
+}

data/lib/relaton/bib.rb

@@ -0,0 +1,48 @@
+require "relaton/logger"
+require "forwardable"
+# require "htmlentities"
+require "bibtex"
+require "iso639"
+require "rfcxml"
+require "relaton/core"
+require_relative "version"
+require_relative "bib/util"
+require_relative "bib/sanitizer"
+require_relative "bib/namespace_helper"
+require_relative "bib/item_data"
+require_relative "bib/model/item"
+require_relative "bib/model/item_base"
+require_relative "bib/model/bibitem_shared"
+require_relative "bib/model/bibdata_shared"
+require_relative "bib/model/bibitem"
+require_relative "bib/model/bibdata"
+require_relative "bib/converter/bibxml"
+require_relative "bib/converter/bibtex"
+require_relative "bib/converter/asciibib"
+require_relative "bib/model/relation"
+
+module Relaton
+  # class Error < StandardError; end
+
+  class RequestError < StandardError; end
+
+  class << self
+    #
+    # Read schema versions from file
+    #
+    # @return [Hash{String=>String}] schema versions
+    #
+    def schema_versions
+      @@schema_versions ||= JSON.parse File.read(File.join(__dir__, "bib/versions.json"))
+    end
+  end
+
+  module Bib
+    def self.grammar_hash
+      # gem_path = File.expand_path "..", __dir__
+      # grammars_path = File.join gem_path, "grammars", "*"
+      # grammars = Dir[grammars_path].sort.map { |gp| File.read gp }.join
+      Digest::MD5.hexdigest Relaton::VERSION # grammars
+    end
+  end
+end