relaton-bib 1.20.7 → 2.0.0.pre.alpha.1

data/lib/relaton/bib/item_data.rb

@@ -0,0 +1,168 @@
+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
+      attr_accessor :id, :type, :schema_version, :fetched, :formattedref,
+                    :docidentifier, :docnumber, :date, :contributor, :edition,
+                    :version, :note, :language, :locale, :script, :status,
+                    :copyright, :series, :medium, :place, :price, :extent,
+                    :size, :accesslocation, :license, :classification,
+                    :keyword, :validity, :depiction, :ext # , :all_parts
+
+      attr_writer :title, :abstract, :source, :relation
+
+      def initialize(**args)
+        args.each do |k, v|
+          instance_variable_set("@#{k}", v) if respond_to?("#{k}=")
+        end
+        self.schema_version = schema
+      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)
+        raise NotImplementedError, "`create_id` method not implemented in #{self.class}"
+      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 ? Bibdata.to_xml(self) : Bibitem.to_xml(self)
+        end
+      end
+
+      def to_yaml(**opts)
+        add_notes opts[:note] do
+          Item.to_yaml(self)
+        end
+      end
+
+      def to_json(**opts)
+        add_notes opts[:note] do
+          Item.to_json(self)
+        end
+      end
+
+      def to_bibtex
+        Renderer::BibtexBuilder.build(self).to_s
+      end
+
+      def to_rfcxml
+        Renderer::Rfc.transform(self).to_xml
+      end
+
+      def deep_clone
+        Item.from_yaml Item.to_yaml(self)
+      end
+
+      def create_relation(**args)
+        Relation.new(**args)
+      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
+        Relaton.array(ext.structuredidentifier).each(&:to_all_parts!)
+      end
+
+      def ext_remove_date
+        return unless ext
+
+        Relaton.array(ext.structuredidentifier).each(&:remove_date!)
+      end
+
+      private
+
+      def add_notes(notes)
+        self.note ||= []
+        Relaton.array(notes).each { |nt| note << Bib::Note.new(**nt) }
+        result = yield
+        Relaton.array(notes).each { note.pop }
+        result
+      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,24 @@
+module Relaton
+  module Bib
+    module BibdataShared
+      def self.included(base)
+        base.class_eval do
+          model ItemData
+
+          # Bibdata doesn't have id attribute.
+          attributes.delete :id
+          mappings[:xml].instance_variable_get(:@attributes).delete("id")
+
+          xml do
+            root "bibdata"
+          end
+        end
+      end
+    end
+
+    # This class represents a bibliographic item as a bibdata.
+    class Bibdata < Item
+      include BibdataShared
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Relaton
+  module Bib
+    module BibitemShared
+      def self.included(base)
+        base.class_eval do
+          model ItemData
+
+          # This class represents a bibliographic item as a bibitem.
+          attributes.delete :ext
+          mappings[:xml].instance_variable_get(:@elements).delete("ext")
+
+          xml do
+            root "bibitem"
+          end
+        end
+      end
+    end
+
+    class Bibitem < Item
+      include BibitemShared
+    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,16 @@
+module Relaton
+  module Bib
+    class ContributionInfo < Lutaml::Model::Serializable
+      choice(min: 1, max: 1) do
+        attribute :person, Person
+        attribute :organization, Organization
+      end
+
+      xml do
+        no_root
+        map_element "person", to: :person
+        map_element "organization", to: :organization
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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
+      # attribute :entity, ContributionInfo
+      # @TODO: use `import_model ContributionInfo` for person and organization when Lutaml supports it
+      choice(min: 1, max: 1) do
+        attribute :person, Person
+        attribute :organization, Organization
+      end
+      # import_model_attributes ContributionInfo
+
+      xml do
+        root "contributor"
+
+        map_element "role", to: :role
+        # map_content to: :entity, with: { from: :entity_from_xml, to: :entity_to_xml }
+        map_element "person", to: :person
+        map_element "organization", to: :organization # , with: { from: :organization_from_xml, to: :organization_to_xml }
+      end
+
+      # def entity
+      #   person || organization
+      # end
+
+      # def entity=(value)
+      #   if value.is_a? Person
+      #     self.person = value
+      #     self.organization = nil
+      #   elsif value.is_a? Organization
+      #     self.organization = value
+      #     self.person = nil
+      #   else
+      #     raise ArgumentError, "value must be a Person or Organization"
+      #   end
+      # end
+
+      # def organization_from_xml(model, node)
+      #   model.entity = Organization.of_xml node
+      # end
+
+      # def organization_to_xml(model, parent, _doc)
+      #   parent << model.entity.to_xml
+      # end
+
+      # def entity_from_xml(model, node)
+      #   n = node.instance_variable_get(:@node) || node
+      #   model.content = ContributionInfo.of_xml n
+      # rescue StandardError
+      # end
+
+      # def entity_to_xml(model, parent, _doc)
+      #   parent << model.content.to_xml
+      # 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,29 @@
+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, :string
+          attribute :to, :string
+        end
+        # `on` is reserved word in YAML, so use `at` instead to avoid remapping key-value formats
+        attribute :at, :string
+      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,14 @@
+module Relaton
+  module Bib
+    class Depiction < Lutaml::Model::Serializable
+      attribute :scope, :string
+      attribute :image, Image, collection: true, initialize_empty: true
+
+      xml do
+        root "depiction"
+        map_attribute "scope", to: :scope
+        map_element "image", to: :image
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Relaton
+  module Bib
+    class Docidentifier < LocalizedMarkedUpString
+      attribute :type, :string
+      attribute :scope, :string
+      attribute :primary, :boolean
+
+      xml do
+        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/editorial_group.rb

@@ -0,0 +1,14 @@
+require_relative "workgroup"
+
+module Relaton
+  module Bib
+    class EditorialGroup < Lutaml::Model::Serializable
+      attribute :technical_committee, WorkGroup, collection: true, initialize_empty: true
+
+      xml do
+        root "editorialgroup"
+        map_element "technical-committee", to: :technical_committee
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative "doctype"
+require_relative "editorial_group"
+require_relative "ics"
+require_relative "structured_identifier"
+
+module Relaton
+  module Bib
+    class Ext < Lutaml::Model::Serializable
+      attribute :schema_version, :string
+      attribute :doctype, Doctype
+      attribute :subdoctype, :string
+      attribute :flavor, :string
+      attribute :editorialgroup, EditorialGroup
+      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
+        map_element "doctype", to: :doctype
+        map_element "subdoctype", to: :subdoctype
+        map_element "flavor", to: :flavor
+        map_element "editorialgroup", to: :editorialgroup
+        map_element "ics", to: :ics
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+    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/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,14 @@
+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
+    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