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

data/lib/relaton/bib/item_data.rb

@@ -0,0 +1,229 @@
+module Relaton
+  module Bib
+    # This class represents the data of a bibliographic item.
+    # It needed to keep data fot different types of representations (bibitem, bibdata ...).
+    # @TODO: remove this class when Lutaml Model will support transformation between different types of models.
+    class ItemData
+      include Core::ArrayWrapper
+      include NamespaceHelper
+
+      ATTRIBUTES = %i[
+        type schema_version fetched formattedref docnumber edition status
+        medium size validity ext
+      ].freeze
+      COLLECTION_ATTRBUTES = %i[
+        date contributor version note language locale script
+        copyright series place price extent accesslocation license
+        classification keyword depiction
+      ].freeze
+      COLLECTION_WRITE_ONLY_ATTRIBUTES = %i[title abstract source relation].freeze
+
+      ATTRIBUTES.each { |attr| attr_accessor attr }
+      COLLECTION_ATTRBUTES.each { |attr| attr_accessor attr }
+      COLLECTION_WRITE_ONLY_ATTRIBUTES.each { |attr| attr_writer attr }
+
+      attr_reader :id, :docidentifier
+
+      def initialize(**args)
+        ATTRIBUTES.each { |attr| instance_variable_set("@#{attr}", args[attr]) }
+
+        (COLLECTION_ATTRBUTES + COLLECTION_WRITE_ONLY_ATTRIBUTES).each do |attr|
+          instance_variable_set("@#{attr}", args[attr] || [])
+        end
+
+        @docidentifier = args[:docidentifier] || []
+        self.schema_version = schema
+        @id = args[:id]
+        create_id
+      end
+
+      def id=(value)
+        @id = value if value
+      end
+
+      def docidentifier=(value)
+        @docidentifier = value || []
+        create_id
+      end
+
+      #
+      # Fetch schema version
+      #
+      # @return [String] schema version
+      #
+      def schema
+        @schema ||= Relaton.schema_versions["relaton-models"]
+      end
+
+      def to_relation_item
+        self.id = nil
+        self.schema_version = nil
+        self.fetched = nil
+        ext&.schema_version = nil
+      end
+
+      # remove title part components and abstract
+      def to_all_parts # rubocop:disable Metrics/MethodLength
+        me = deep_clone
+        me.relation ||= []
+        to_relation_item
+        me.relation << create_relation(type: "instanceOf", bibitem: self)
+        me.delete_title_part!
+        me.title_update_main
+        me.abstract = []
+        me.docidentifier.each(&:to_all_parts!)
+        me.ext_to_all_parts!
+        # me.all_parts = true
+        me
+      end
+
+      def to_most_recent_reference
+        me = deep_clone
+        to_relation_item
+        me.relation ||= []
+        me.relation << create_relation(type: "instanceOf", bibitem: self)
+        me.abstract = []
+        me.date = []
+        me.docidentifier.each(&:remove_date!)
+        me.ext_remove_date
+        me.create_id without_date: true
+        me
+      end
+
+      def create_id(without_date: false)
+        return id if id && !id.empty?
+
+        docid = find_primary_docid
+        return unless docid
+
+        pubid = without_date ? docid.content.sub(/:\d{4}$/, "") : docid.content
+        self.id = pubid.to_s.gsub(/\W+/, "")
+      end
+
+      def title(lang = nil)
+        return @title if lang.nil?
+
+        @title.select { |t| t.language == lang.to_s }
+      end
+
+      def abstract(lang = nil)
+        return @abstract if lang.nil?
+
+        @abstract.select { |a| a.language == lang.to_s }
+      end
+
+      def source(src = nil)
+        return @source if src.nil?
+
+        @source.find { |s| s.type == src.to_s }&.content
+      end
+
+      def relation(type = nil)
+        return @relation if type.nil?
+
+        @relation&.select { |r| r.type == type.to_s }
+      end
+
+      def to_xml(bibdata: false, **opts)
+        add_notes opts[:note] do
+          bibdata ? namespace::Bibdata.to_xml(self) : namespace::Bibitem.to_xml(self)
+        end
+      end
+
+      def to_yaml(**opts)
+        add_notes opts[:note] do
+          namespace::Item.to_yaml(self)
+        end
+      end
+
+      def to_json(**opts)
+        add_notes opts[:note] do
+          namespace::Item.to_json(self)
+        end
+      end
+
+      def to_h(**opts)
+        add_notes opts[:note] do
+          namespace::Item.to_hash(self)
+        end
+      end
+
+      def to_bibtex
+        Converter::Bibtex.from_item(self).to_s
+      end
+
+      def to_asciibib
+        Converter::Asciibib.from_item(self)
+      end
+
+      def to_rfcxml
+        Converter::BibXml.from_item(self).to_xml
+      end
+
+      def deep_clone
+        namespace::Item.from_yaml namespace::Item.to_yaml(self)
+      end
+
+      def create_relation(**args)
+        if defined?(namespace::Relation)
+          namespace::Relation.new(**args)
+        else
+          Relation.new(**args)
+        end
+      end
+
+      def delete_title_part!
+        title&.delete_if { |t| t.type == "title-part" }
+      end
+
+      def title_update_main # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        language&.each do |lang|
+          ttl = title.select { |t| t.type != "main" && t.language == lang }
+          next if ttl.empty?
+
+          tm_lang = ttl.map(&:content).join " - "
+          title.detect { |t| t.type == "main" && t.language == lang }&.content = tm_lang
+        end
+      end
+
+      def ext_to_all_parts!
+        return unless ext
+
+        # some flavor modles have structuredidentifier as not an array
+        # so we need to make it an array use common method
+        array(ext.structuredidentifier).each(&:to_all_parts!)
+      end
+
+      def ext_remove_date
+        return unless ext
+
+        array(ext.structuredidentifier).each(&:remove_date!)
+      end
+
+      private
+
+      def find_primary_docid
+        prim_docids = docidentifier.select(&:primary)
+        case prim_docids.size
+        when 0 then find_primary_or_english_docid(docidentifier)
+        when 1 then prim_docids.first
+        else find_primary_or_english_docid(prim_docids)
+        end
+      end
+
+      def find_primary_or_english_docid(docids) # rubocop:disable Metrics/CyclomaticComplexity
+        docids.reject(&:language).first ||
+          docids.find { |i| i.language&.casecmp("en")&.zero? } ||
+          docids.first
+      end
+
+      def add_notes(notes)
+        self.note ||= []
+        array(notes).each { |nt| note << Bib::Note.new(**nt) }
+        result = yield
+        array(notes).each { note.pop }
+        result
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+module Relaton
+  module Bib
+    class Address < Lutaml::Model::Serializable
+      attribute :street, :string, collection: true, initialize_empty: true
+      attribute :city, :string
+      attribute :state, :string
+      attribute :country, :string
+      attribute :postcode, :string
+      attribute :formatted_address, :string, raw: true
+
+      xml do
+        root "address"
+        map_element "street", to: :street
+        map_element "city", to: :city
+        map_element "state", to: :state
+        map_element "country", to: :country
+        map_element "postcode", to: :postcode
+        map_element "formattedAddress", to: :formatted_address
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Affiliation < Lutaml::Model::Serializable
+      attribute :name, LocalizedString
+      attribute :description, LocalizedMarkedUpString, collection: true, initialize_empty: true
+      attribute :organization, Organization
+
+      xml do
+        root "affiliation"
+        map_element "name", to: :name
+        map_element "description", to: :description
+        map_element "organization", to: :organization
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require_relative "bibdata_shared"
+
+module Relaton
+  module Bib
+    # Bibliographic item serialized as <bibdata>. Has ext, no id.
+    class Bibdata < Item
+      model ItemData
+      include BibdataShared
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative "item_shared"
+
+module Relaton
+  module Bib
+    module BibdataShared
+      def self.included(base)
+        base.xml { root "bibdata" }
+        ItemShared.prune_attribute(base, :id, "id")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require_relative "bibitem_shared"
+
+module Relaton
+  module Bib
+    # Bibliographic item serialized as <bibitem>. Has id, no ext.
+    class Bibitem < Item
+      model ItemData
+      include BibitemShared
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative "item_shared"
+
+module Relaton
+  module Bib
+    module BibitemShared
+      def self.included(base)
+        base.xml { root "bibitem" }
+        ItemShared.prune_attribute(base, :ext, "ext")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative "address"
+require_relative "phone"
+require_relative "uri"
+
+module Relaton
+  module Bib
+    module Contact
+      def self.included(base)
+        base.instance_eval do
+          attribute :address, Address, collection: true, initialize_empty: true
+          attribute :phone, Phone, collection: true, initialize_empty: true
+          attribute :email, :string, collection: true, initialize_empty: true
+          attribute :uri, Uri, collection: true, initialize_empty: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Relaton
+  module Bib
+    class ContributionInfo < Lutaml::Model::Serializable
+      choice(min: 1, max: 1) do
+        attribute :person, Person
+        attribute :organization, Organization
+      end
+
+      xml do
+        map_element "person", to: :person
+        map_element "organization", to: :organization
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Relaton
+  module Bib
+    class Contributor < Lutaml::Model::Serializable
+      class Role < Lutaml::Model::Serializable
+        attribute :type, :string, values: %w[
+          author performer publisher editor adapter translator distributor reazer
+          owner authorizer enabler subject
+        ]
+        attribute :description, LocalizedMarkedUpString, collection: true, initialize_empty: true
+
+        xml do
+          root "role"
+          map_attribute "type", to: :type
+          map_element "description", to: :description
+        end
+      end
+
+      attribute :role, Role, collection: true, initialize_empty: true
+      import_model_attributes ContributionInfo
+
+      xml do
+        root "contributor"
+
+        map_element "role", to: :role
+        import_model_mappings ContributionInfo
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Relaton
+  module Bib
+    class Copyright < Lutaml::Model::Serializable
+      attribute :from, :string
+      attribute :to, :string
+      attribute :owner, ContributionInfo, collection: true, initialize_empty: true
+      attribute :scope, :string
+
+      xml do
+        root "copyright"
+
+        map_element "from", to: :from
+        map_element "to", to: :to
+        map_element "owner", to: :owner # , with: { from: :owner_from_xml, to: :owner_to_xml }
+        map_element "scope", to: :scope
+      end
+
+      # def owner_from_xml(model, node)
+      #   model.owner = ContributionInfo.from_xml node
+      # end
+
+      # def owner_to_xml(model, parent, _doc)
+      #   model.owner.to_xml parent
+      # end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require_relative "type/string_date"
+
+module Relaton
+  module Bib
+    class Date < Lutaml::Model::Serializable
+      attribute :type, :string, values: %w[
+        published accessed created implemented obsoleted confirmed updated
+        corrected issued transmitted copied unchanged circulated adapted
+        vote-started vote-ended announced stable-until
+      ]
+      attribute :text, :string
+      choice(min: 1, max: 2) do
+        choice(min: 1, max: 2) do
+          attribute :from, StringDate
+          attribute :to, StringDate
+        end
+        # `on` is reserved word in YAML, so we use `at` to avoid remapping key-value formats
+        attribute :at, StringDate
+      end
+
+      xml do
+        root "date"
+        map_attribute "type", to: :type
+        map_attribute "text", to: :text
+        map_element "from", to: :from
+        map_element "to", to: :to
+        map_element "on", to: :at
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Depiction < Lutaml::Model::Serializable
+      attribute :scope, :string
+      attribute :type, :string
+      attribute :image, Image, collection: true, initialize_empty: true
+
+      xml do
+        root "depiction"
+        map_attribute "scope", to: :scope
+        map_attribute "type", to: :type
+        map_element "image", to: :image
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Relaton
+  module Bib
+    class Docidentifier < LocalizedMarkedUpString
+      attribute :type, :string
+      attribute :scope, :string
+      attribute :primary, :boolean
+
+      xml do
+        root "docidentifier"
+        map_attribute "type", to: :type
+        map_attribute "scope", to: :scope
+        map_attribute "primary", to: :primary
+      end
+
+      key_value do
+        map "type", to: :type
+        map "scope", to: :scope
+        map "primary", to: :primary
+      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/doctype.rb

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

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

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

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

@@ -0,0 +1,39 @@
+require_relative "doctype"
+require_relative "ics"
+require_relative "structured_identifier"
+
+module Relaton
+  module Bib
+    class Ext < Lutaml::Model::Serializable
+      attribute :schema_version, :string, method: :get_schema_version
+      attribute :doctype, Doctype
+      attribute :subdoctype, :string
+      attribute :flavor, :string
+      attribute :ics, ICS, collection: true, initialize_empty: true
+      attribute :structuredidentifier, StructuredIdentifier, collection: true, initialize_empty: true
+
+      xml do
+        root "ext"
+        map_attribute "schema-version", to: :schema_version, render_default: true
+        map_element "doctype", to: :doctype
+        map_element "subdoctype", to: :subdoctype
+        map_element "flavor", to: :flavor
+        map_element "ics", to: :ics
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+
+      key_value do
+        map_element "schema_version", to: :schema_version, render_default: true
+        map_element "doctype", to: :doctype
+        map_element "subdoctype", to: :subdoctype
+        map_element "flavor", to: :flavor
+        map_element "ics", to: :ics
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+
+      # Base returns nil so direct use omits schema-version. Subclasses in
+      # downstream relaton gems override to return their own version.
+      def get_schema_version = nil
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Extent < Lutaml::Model::Serializable
+      choice(min: 1, max: 1) do
+        attribute :locality, Locality, collection: true, initialize_empty: true
+        attribute :locality_stack, LocalityStack, collection: true, initialize_empty: true
+      end
+
+      xml do
+        root "extent"
+        map_element "locality", to: :locality
+        map_element "localityStack", to: :locality_stack
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Relaton
+  module Bib
+    class Formattedref < LocalizedMarkedUpString
+      attribute :format, :string
+
+      xml do
+        root "formattedref"
+        map_attribute "format", to: :format
+      end
+
+      key_value do
+        map "format", to: :format
+      end
+
+      # Handle plain string input from YAML/JSON deserialization
+      def self.from_yaml(value)
+        return new(content: value) if value.is_a?(String)
+
+        super
+      end
+
+      def self.from_json(value)
+        return new(content: value) if value.is_a?(String)
+
+        super
+      end
+
+      # Serialize as plain string when only content is present
+      def self.as(format, instance, options = {})
+        return instance.content if simple_content?(instance, format)
+
+        super
+      end
+
+      def self.simple_content?(instance, format)
+        return false if format == :xml
+
+        instance.format.nil? && instance.language.nil? &&
+          instance.script.nil? && instance.locale.nil?
+      end
+    end
+  end
+end