relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.1

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

@@ -0,0 +1,64 @@
+module Relaton
+  module Bib
+    module FullNameType
+      class Forename < LocalizedString
+        attribute :initial, :string
+
+        xml do
+          map_attribute "initial", to: :initial
+        end
+
+        key_value do
+          map "initial", to: :initial
+        end
+      end
+
+      def self.included(base) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        base.instance_eval do
+          attribute :abbreviation, LocalizedString
+          attribute :prefix, LocalizedString, collection: true, initialize_empty: true
+          attribute :forename, Forename, collection: true, initialize_empty: true
+          attribute :formatted_initials, LocalizedString
+          attribute :surname, LocalizedString
+          attribute :addition, LocalizedString, collection: true, initialize_empty: true
+          attribute :completename, LocalizedString
+          attribute :note, Note, collection: true, initialize_empty: true
+          attribute :variant, Variant, collection: true, initialize_empty: true
+
+          xml do
+            map_element "abbreviation", to: :abbreviation
+            map_element "prefix", to: :prefix
+            map_element "forename", to: :forename
+            map_element "formatted-initials", to: :formatted_initials
+            map_element "surname", to: :surname
+            map_element "addition", to: :addition
+            map_element "completename", to: :completename
+            map_element "note", to: :note
+            map_element "variant", to: :variant
+          end
+        end
+      end
+
+      # def content_from_xml(model, node)
+      #   model.content = Content.of_xml node.instance_variable_get(:@node) || node
+      # end
+
+      # def content_to_xml(model, parent, _doc)
+      #   model.content.add_to_xml parent
+      # end
+    end
+
+    module FullNameType
+      class Variant < Lutaml::Model::Serializable
+        include FullNameType
+
+        attribute :type, :string
+
+        xml do
+          root "variant"
+          map_attribute "type", to: :type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Relaton
+  module Bib
+    class FullName < Lutaml::Model::Serializable
+      include FullNameType
+
+      xml do
+        root "name"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "isoics"
+
+module Relaton
+  module Bib
+    class ICS < Lutaml::Model::Serializable
+      attribute :code, :string
+      attribute :text, :string
+
+      xml do
+        root "ics"
+        map_element "code", to: :code
+        map_element "text", to: :text
+      end
+
+      # Returns the explicit text if set, else the Isoics description for
+      # `code`. Kept for consumers that read `.text` directly.
+      def text
+        return @text if @text.is_a?(String) && !@text.empty?
+
+        Isoics.fetch(code)&.description if code.is_a?(String) && !code.empty?
+      end
+
+      # When code is assigned, eagerly populate text from Isoics if no
+      # explicit text has been set. Going through the public writer
+      # registers the value with the lutaml-model `value_set_for` tracker
+      # so the attribute is emitted on serialization.
+      def code=(val)
+        super
+        return unless val.is_a?(String) && !val.empty?
+        return if @text.is_a?(String) && !@text.empty?
+
+        description = Isoics.fetch(val)&.description
+        self.text = description if description
+      end
+
+      # When the deserializer reaches the end of the XML element and
+      # records that <text> was absent, it calls `using_default_for(:text)`
+      # to mark the attribute as default-valued (suppressing serialization).
+      # Refuse that mark if we've already populated text from Isoics so the
+      # value survives round-trip. See #112.
+      def using_default_for(attribute_name)
+        return if attribute_name == :text &&
+          @text.is_a?(String) && !@text.empty?
+
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Relaton
+  module Bib
+    class Image < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :src, :string # anyURI
+      attribute :mimetype, :string
+      attribute :filename, :string
+      attribute :width, :string
+      attribute :height, :string
+      attribute :alt, :string
+      attribute :title, :string
+      attribute :longdesc, :string # anyURI
+
+      xml do
+        root "image"
+        map_attribute "id", to: :id
+        map_attribute "src", to: :src
+        map_attribute "mimetype", to: :mimetype
+        map_attribute "filename", to: :filename
+        map_attribute "width", to: :width
+        map_attribute "height", to: :height
+        map_attribute "alt", to: :alt
+        map_attribute "title", to: :title
+        map_attribute "longdesc", to: :longdesc
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require "lutaml/model"
+require "lutaml/xml"
+
+# lutaml/xml registers :doctype as an attr_accessor on Serializable (for the
+# <!DOCTYPE …> XML declaration) and adds it to the override-warning list.
+# Relaton's :doctype attribute models the document-type field
+# (international-standard, technical-report, …); the override is intentional.
+Lutaml::Model::Attribute.format_specific_warn_names.delete(:doctype)
+
+require_relative "localized_string_attrs"
+require_relative "localized_string"
+require_relative "formattedref"
+require_relative "abstract"
+require_relative "date"
+require_relative "locality"
+require_relative "locality_stack"
+require_relative "image"
+require_relative "title"
+require_relative "docidentifier"
+require_relative "note"
+require_relative "full_name_type"
+require_relative "fullname"
+require_relative "contact"
+require_relative "logo"
+require_relative "organization"
+require_relative "affiliation"
+require_relative "person"
+require_relative "contribution_info"
+require_relative "contributor"
+require_relative "edition"
+require_relative "version"
+require_relative "status"
+require_relative "copyright"
+require_relative "place"
+require_relative "series"
+require_relative "medium"
+require_relative "uri"
+require_relative "price"
+require_relative "extent"
+require_relative "size"
+require_relative "keyword"
+require_relative "validity"
+require_relative "depiction"
+require_relative "source_locality_stack"
+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
+    end
+
+    # Item class repesents bibliographic item metadata.
+    # Used for YAML/JSON parsing and as the XML dispatch entry point.
+    class Item < Lutaml::Model::Serializable
+      include NamespaceHelper
+
+      attr_accessor :type # in some cases mehod type is unavailable
+
+      model ItemData
+
+      def self.from_xml(xml, options = {})
+        return super unless self == namespace::Item
+
+        # 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
+        klass = root_name == "bibdata" ? namespace::Bibdata : namespace::Bibitem
+        klass.from_xml(xml, options)
+      end
+
+      attribute :id, :string
+      attribute :schema_version, :string, method: :get_schema_version
+      attribute :fetched, PlainDate
+      instance_exec(&ItemShared::ATTRIBUTES)
+      attribute :ext, Ext
+
+      xml do
+        map_attribute "id", to: :id
+        map_attribute "type", to: :type
+        map_attribute "schema-version", to: :schema_version, render_default: true
+        map_element "fetched", to: :fetched
+        instance_exec(&ItemShared::XML_BODY)
+        map_element "ext", to: :ext
+      end
+
+      def get_schema_version = Relaton.schema_versions["relaton-models"]
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Relaton
+  module Bib
+    # Bibliographic item used as a nested element inside Relation.
+    # Has neither id, schema_version, fetched, nor ext.
+    class ItemBase < Lutaml::Model::Serializable
+      include NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&ItemShared::ATTRIBUTES)
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&ItemShared::XML_BODY)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Relaton
+  module Bib
+    # Shared attribute and XML mapping declarations for Item/Bibitem/Bibdata/ItemBase.
+    # Each class composes these with its own header (id/schema_version/fetched/ext)
+    # via instance_exec, so subtractive monkey-patching of inherited mappings is
+    # not needed.
+    module ItemShared
+      ATTRIBUTES = lambda do # rubocop:disable Metrics/BlockLength
+        attribute :type, :string, values: %W[
+          article book booklet manual proceedings presentation thesis techreport standard
+          unpublished map electronic\sresource audiovisual film video boradcast software
+          graphic_work music patent inbook incollection inproceedings journal website
+          webresource dataset archival social_media alert message convesation misc
+        ]
+        attribute :formattedref, Formattedref
+        attribute :title, Title, collection: true, initialize_empty: true
+        attribute :source, Uri, collection: true, initialize_empty: true
+        attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+        attribute :docnumber, :string
+        attribute :date, Date, collection: true, initialize_empty: true
+        attribute :contributor, Contributor, collection: true, initialize_empty: true
+        attribute :edition, Edition
+        attribute :version, Version, collection: true, initialize_empty: true
+        attribute :note, Note, collection: true, initialize_empty: true
+        attribute :language, :string, collection: true, initialize_empty: true
+        attribute :locale, :string, collection: true, initialize_empty: true
+        attribute :script, :string, collection: true, initialize_empty: true
+        attribute :abstract, Abstract, collection: true, initialize_empty: true
+        attribute :status, Status
+        attribute :copyright, Copyright, collection: true, initialize_empty: true
+        attribute :relation, Relation, collection: true, initialize_empty: true
+        attribute :series, Series, collection: true, initialize_empty: true
+        attribute :medium, Medium
+        attribute :place, Place, collection: true, initialize_empty: true
+        attribute :price, Price, collection: true, initialize_empty: true
+        attribute :extent, Extent, collection: true, initialize_empty: true
+        attribute :size, Size
+        attribute :accesslocation, :string, collection: true, initialize_empty: true
+        attribute :license, :string, collection: true, initialize_empty: true
+        attribute :classification, Docidentifier, collection: true, initialize_empty: true
+        attribute :keyword, Keyword, collection: true, initialize_empty: true
+        attribute :validity, Validity
+        attribute :depiction, Depiction, collection: true, initialize_empty: true
+      end
+
+      def self.prune_attribute(base, attr_name, xml_name)
+        return unless base.attributes.key?(attr_name)
+
+        xml_mapping = base.mappings[:xml]
+        xml_mapping.instance_variable_get(:@elements).delete(xml_name)
+        xml_mapping.instance_variable_get(:@attributes).delete(xml_name)
+        base.attributes.delete(attr_name)
+      end
+
+      XML_BODY = lambda do # rubocop:disable Metrics/BlockLength
+        map_element "formattedref", to: :formattedref
+        map_element "title", to: :title
+        map_element "uri", to: :source
+        map_element "docidentifier", to: :docidentifier
+        map_element "docnumber", to: :docnumber
+        map_element "date", to: :date
+        map_element "contributor", to: :contributor
+        map_element "edition", to: :edition
+        map_element "version", to: :version
+        map_element "note", to: :note
+        map_element "language", to: :language
+        map_element "locale", to: :locale
+        map_element "script", to: :script
+        map_element "abstract", to: :abstract
+        map_element "status", to: :status
+        map_element "copyright", to: :copyright
+        map_element "relation", to: :relation
+        map_element "series", to: :series
+        map_element "medium", to: :medium
+        map_element "place", to: :place
+        map_element "price", to: :price
+        map_element "extent", to: :extent
+        map_element "size", to: :size
+        map_element "accesslocation", to: :accesslocation
+        map_element "license", to: :license
+        map_element "classification", to: :classification
+        map_element "keyword", to: :keyword
+        map_element "validity", to: :validity
+        map_element "depiction", to: :depiction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Relaton
+  module Bib
+    class Keyword < Lutaml::Model::Serializable
+      class Vocabid < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :uri, :string
+        attribute :code, :string
+        attribute :term, :string
+
+        xml do
+          map_attribute "type", to: :type
+          map_attribute "uri", to: :uri
+          map_element "code", to: :code
+          map_element "term", to: :term
+        end
+      end
+
+      attribute :vocab, LocalizedString
+      attribute :taxon, LocalizedString, collection: true, initialize_empty: true
+      attribute :vocabid, Vocabid, collection: true, initialize_empty: true
+
+      xml do
+        root "keyword"
+        map_element "vocab", to: :vocab
+        map_element "taxon", to: :taxon
+        map_element "vocabid", to: :vocabid
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    class Locality < Lutaml::Model::Serializable
+      attribute :type, :string, pattern: %r{
+        section|clause|part|paragraph|chapter|page|title|line|whole|table|annex|
+        figure|note|list|example|volume|issue|time|anchor|locality:[a-zA-Z0-9_]+
+      }x
+      attribute :reference_from, :string
+      attribute :reference_to, :string
+
+      xml do
+        map_attribute "type", to: :type
+        map_element "referenceFrom", to: :reference_from
+        map_element "referenceTo", to: :reference_to
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,48 @@
+module Relaton
+  module Bib
+    class LocalizedString < LocalizedStringAttrs
+      attribute :content, :string
+
+      xml do
+        map_content to: :content
+      end
+
+      key_value do
+        map "content", to: :content
+        map "language", to: :language
+      end
+    end
+
+    class TypedLocalizedString < LocalizedString
+      attribute :type, :string
+
+      xml do
+        map_attribute "type", to: :type
+      end
+
+      key_value do
+        map "type", to: :type
+      end
+    end
+
+    class LocalizedMarkedUpString < LocalizedStringAttrs
+      module ContentSanitization
+        def content=(value)
+          super(Relaton::Bib::Sanitizer.sanitize(value))
+        end
+      end
+
+      attribute :content, :string, raw: true
+      prepend ContentSanitization
+
+      xml do
+        map_all to: :content
+      end
+
+      key_value do
+        map "content", to: :content
+        map "language", to: :language
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Relaton
+  module Bib
+    class LocalizedStringAttrs < Lutaml::Model::Serializable
+      attribute :language, :string
+      attribute :locale, :string
+      attribute :script, :string
+
+      # def self.inherited(base)
+      #   super
+      #   base.class_eval do
+      xml do
+        map_attribute "language", to: :language
+        map_attribute "locale", to: :locale
+        map_attribute "script", to: :script
+      end
+
+      key_value do
+        map "language", to: :language
+        map "locale", to: :locale
+        map "script", to: :script
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Relaton
+  module Bib
+    class Logo < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :image, Image
+
+      xml do
+        root "logo"
+        map_attribute "type", to: :type
+        map_element "image", to: :image
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Relaton
+  module Bib
+    class Medium < Lutaml::Model::Serializable
+      attribute :content, :string
+      attribute :genre, :string
+      attribute :form, :string
+      attribute :carrier, :string
+      attribute :size, :string
+      attribute :scale, :string
+
+      xml do
+        root "medium"
+        map_element "content", to: :content
+        map_element "genre", to: :genre
+        map_element "form", to: :form
+        map_element "carrier", to: :carrier
+        map_element "size", to: :size
+        map_element "scale", to: :scale
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Note < LocalizedMarkedUpString
+      attribute :type, :string
+
+      xml do
+        root "note"
+        map_attribute "type", to: :type
+      end
+
+      key_value do
+        map "type", to: :type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "organization_type"
+
+module Relaton
+  module Bib
+    class Organization < Lutaml::Model::Serializable
+      include OrganizationType
+
+      xml do
+        root "organization"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Relaton
+  module Bib
+    module OrganizationType
+      class Identifier < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :content, :string
+
+        xml do
+          root "identifier"
+          map_attribute "type", to: :type
+          map_content to: :content
+        end
+      end
+
+      def self.included(base) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        require_relative "subdivision"
+
+        base.instance_eval do
+          include Contact
+
+          attribute :name, TypedLocalizedString, collection: true, initialize_empty: true
+          attribute :subdivision, Subdivision, collection: true, initialize_empty: true
+          attribute :abbreviation, LocalizedString
+          attribute :identifier, Identifier, collection: true, initialize_empty: true
+          attribute :logo, Logo, collection: true, initialize_empty: true
+
+          xml do
+            map_element "name", to: :name
+            map_element "subdivision", to: :subdivision
+            map_element "abbreviation", to: :abbreviation
+            map_element "identifier", to: :identifier
+            map_element "address", to: :address
+            map_element "phone", to: :phone
+            map_element "email", to: :email
+            map_element "uri", to: :uri
+            map_element "logo", to: :logo
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Relaton
+  module Bib
+    class Person < Lutaml::Model::Serializable
+      class Identifier < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :content, :string
+
+        xml do
+          root "identifier"
+          map_attribute "type", to: :type
+          map_content to: :content
+        end
+      end
+
+      include Contact
+
+      attribute :name, FullName
+      attribute :credential, :string, collection: true, initialize_empty: true
+      attribute :affiliation, Affiliation, collection: true, initialize_empty: true
+      attribute :identifier, Identifier, collection: true, initialize_empty: true
+
+      xml do
+        root "person"
+
+        map_element "name", to: :name
+        map_element "credential", to: :credential
+        map_element "affiliation", to: :affiliation
+        map_element "identifier", to: :identifier
+        map_element "address", to: :address
+        map_element "phone", to: :phone
+        map_element "email", to: :email
+        map_element "uri", to: :uri
+      end
+    end
+  end
+end

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

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