relaton-bib 0.1.0

data/lib/relaton_bib/classification.rb

@@ -0,0 +1,22 @@
+module RelatonBib
+  class Classification
+    # @return [String, NilClass]
+    attr_reader :type
+
+    # @return [String]
+    attr_reader :value
+
+    # @param type [String, NilClass]
+    # @param value [String]
+    def initialize(type: nil, value:)
+      @type  = type
+      @value = value
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      xml = builder.classification value
+      xml[:type] = type if type
+    end
+  end
+end

data/lib/relaton_bib/contribution_info.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "relaton_bib/person"
+
+# RelatonBib module
+module RelatonBib
+  # Contributor's role.
+  class ContributorRole
+    TYPES = %w[author performer publisher editor adapter translator
+               distributor].freeze
+
+    # @return [Array<RelatonBib::FormattedString>]
+    attr_reader :description
+
+    # @return [ContributorRoleType]
+    attr_reader :type
+
+    # @param type [String] allowed types "author", "editor",
+    #   "cartographer", "publisher"
+    # @param description [Array<String>]
+    def initialize(*args)
+      @type = args.fetch 0
+      if type && !TYPES.include?(type)
+        raise ArgumentError, %{Type "#{type}" is invalid.}
+      end
+
+      @description = args.fetch(1, []).map { |d| FormattedString.new content: d, format: nil }
+    end
+
+    def to_xml(builder)
+      builder.role(type: type) do
+        description.each do |d|
+          builder.description { |desc| d.to_xml(desc) }
+        end
+      end
+    end
+  end
+
+  # Contribution info.
+  class ContributionInfo
+    # @return [Array<RelatonBib::ContributorRole>]
+    attr_reader :role
+
+    # @return
+    #   [RelatonBib::Person, RelatonBib::Organization,
+    #    RelatonBib::IsoProjectGroup]
+    attr_reader :entity
+
+    # @param entity [RelatonBib::Person, RelatonBib::Organization,
+    #   RelatonBib::IsoProjectGroup]
+    # @param role [Array<String>]
+    def initialize(entity:, role: ["publisher"])
+      @entity = entity
+      @role   = role.map { |r| ContributorRole.new(*r) }
+    end
+
+    def to_xml(builder)
+      entity.to_xml builder
+    end
+  end
+end

data/lib/relaton_bib/contributor.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module RelatonBib
+  # Address class.
+  class Address
+    # @return [Array<String>]
+    attr_reader :street
+
+    # @return [String]
+    attr_reader :city
+
+    # @return [String, NilClass]
+    attr_reader :state
+
+    # @return [String]
+    attr_reader :country
+
+    # @return [String, NilClass]
+    attr_reader :postcode
+
+    # @param street [Array<String>]
+    # @param city [String]
+    # @param state [String]
+    # @param country [String]
+    # @param postcode [String]
+    def initialize(street:, city:, state: nil, country:, postcode: nil)
+      @street   = street
+      @city     = city
+      @state    = state
+      @country  = country
+      @postcode = postcode
+    end
+
+    # @param builder [Nokogiri::XML::Document]
+    def to_xml(doc)
+      doc.address do
+        street.each { |str| doc.street str }
+        doc.city city
+        doc.state state if state
+        doc.country country
+        doc.postcode postcode if postcode
+      end
+    end
+  end
+
+  # Contact class.
+  class Contact
+    # @return [String] allowed "phone", "email" or "uri"
+    attr_reader :type
+
+    # @return [String]
+    attr_reader :value
+
+    # @param phone [String]
+    def initialize(type:, value:)
+      @type  = type
+      @value = value
+    end
+
+    # @param builder [Nokogiri::XML::Document]
+    def to_xml(doc)
+      doc.send type, value
+    end
+  end
+
+  # Affilation.
+  class Affilation
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :name
+
+    # @return [Array<RelatonBib::FormattedString>]
+    attr_reader :description
+
+    # @return [RelatonBib::Organization]
+    attr_reader :organization
+
+    # @param organization [RelatonBib::Organization]
+    def initialize(organization)
+      @organization = organization
+      @description  = []
+    end
+
+    # @params builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.affiliation do
+        builder.name { name.to_xml builder } if name
+        description.each { |d| builder.description { d.to_xml builder } }
+        organization.to_xml builder
+      end
+    end
+  end
+
+  # Contributor.
+  class Contributor
+    # @return [URI]
+    attr_reader :uri
+
+    # @return [Array<RelatonBib::Address, RelatonBib::Phone>]
+    attr_reader :contacts
+
+    # @param url [String]
+    # @param contacts [Array<RelatonBib::Address, RelatonBib::Phone>]
+    def initialize(url: nil, contacts: [])
+      @uri = URI url if url
+      @contacts = contacts
+    end
+
+    # Returns url.
+    # @return [String]
+    def url
+      @uri.to_s
+    end
+
+    # @params builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      contacts.each { |contact| contact.to_xml builder }
+    end
+  end
+end

data/lib/relaton_bib/copyright_association.rb

@@ -0,0 +1,38 @@
+module RelatonBib
+  # Copyright association.
+  class CopyrightAssociation
+    # @return [Time]
+    attr_reader :from
+
+    # @return [Time]
+    attr_reader :to
+
+    # @return [RelatonBib::ContributionInfo]
+    attr_reader :owner
+
+    # @param owner [Hash, RelatonBib::ContributionInfo] contributor
+    # @option owner [String] :name
+    # @option owner [String] :abbreviation
+    # @option owner [String] :url
+    # @param from [String] date
+    # @param to [String] date
+    def initialize(owner:, from:, to: nil)
+      @owner = if owner.is_a?(Hash)
+                 ContributionInfo.new entity: Organization.new(owner)
+               else owner
+               end
+
+      @from  = Time.strptime(from, "%Y") unless from.empty?
+      @to    = Time.strptime(to, "%Y") unless to.to_s.empty?
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.copyright do
+        builder.from from.year
+        builder.to to.year if to
+        builder.owner { owner.to_xml builder }
+      end
+    end
+  end
+end

data/lib/relaton_bib/document_identifier.rb

@@ -0,0 +1,26 @@
+module RelatonBib
+  # Document identifier.
+  class DocumentIdentifier
+    # @return [String]
+    attr_reader :id
+
+    # @return [String, NilClass]
+    attr_reader :type
+
+    # @param id [String]
+    # @param type [String, NilClass]
+    def initialize(id:, type: nil)
+      @id   = id
+      @type = type
+    end
+
+    #
+    # Add docidentifier xml element
+    #
+    # @param [Nokogiri::XML::Builder] builder
+    #
+    def to_xml(builder)
+      builder.docidentifier(id, type: type)
+    end
+  end
+end

data/lib/relaton_bib/document_relation.rb

@@ -0,0 +1,49 @@
+module RelatonBib
+  # module DocumentRelationType
+  #   PARENT        = 'parent'
+  #   CHILD         = 'child'
+  #   OBSOLETES     = 'obsoletes'
+  #   UPDATES       = 'updates'
+  #   COMPLEMENTS   = 'complements'
+  #   DERIVED_FORM  = 'derivedForm'
+  #   ADOPTED_FORM  = 'adoptedForm'
+  #   EQUIVALENT    = 'equivalent'
+  #   IDENTICAL     = 'identical'
+  #   NONEQUIVALENT = 'nonequivalent'
+  # end
+
+  # Documett relation
+  class DocumentRelation
+    # @return [String]
+    attr_reader :type
+
+    # @return [String]
+    # attr_reader :identifier, :url
+
+    # @return [RelatonBib::BibliographicItem]
+    attr_reader :bibitem
+
+    # @return [Array<RelatonBib::BibItemLocality>]
+    attr_reader :bib_locality
+
+    # @param type [String]
+    # @param bibitem [RelatonBib::BibliographicItem, RelatonIso::IsoBibliographicItem]
+    # @param bib_locality [Array<RelatonBib::BibItemLocality>]
+    def initialize(type:, bibitem:, bib_locality: [])
+      type = "obsoletes" if type == "Now withdrawn"
+      @type         = type
+      @bib_locality = bib_locality
+      @bibitem      = bibitem
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.relation(type: type) do
+        bibitem.to_xml(builder)
+        bib_locality.each do |l|
+          l.to_xml builder
+        end
+      end
+    end
+  end
+end

data/lib/relaton_bib/document_relation_collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RelatonBib
+  # Document relations collection
+  class DocRelationCollection < Array
+    # @param relations [Array<RelatonBib::DocumentRelation, Hash>]
+    # @option relations [String] :type
+    # @option relations [String] :identifier
+    # @option relations [String, NIllClass] :url (nil)
+    # @option relations [Array<RelatonBib::BibItemLocality>] :bib_locality
+    # @option relations [RelatonBib::BibliographicItem, NillClass] :bibitem (nil)
+    def initialize(relations)
+      super relations.map { |r| r.is_a?(Hash) ? DocumentRelation.new(r) : r }
+    end
+
+    # @return [Array<RelatonBib::DocumentRelation>]
+    def replaces
+      select { |r| r.type == "replace" }
+    end
+  end
+end

data/lib/relaton_bib/document_status.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "relaton_bib/localized_string"
+
+module RelatonBib
+  # Dovument status.
+  class DocumentStatus
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :status
+
+    # @param status [RelatonBib::LocalizedString]
+    def initialize(status)
+      @status = status
+    end
+
+    # @param [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.status do
+        # FormattedString.instance_method(:to_xml).bind(status).call builder
+        status.to_xml builder
+      end
+    end
+  end
+end

data/lib/relaton_bib/formatted_ref.rb

@@ -0,0 +1,11 @@
+require "relaton_bib/formatted_string"
+
+module RelatonBib
+  class FormattedRef < FormattedString
+
+    # @param [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.formattedref { super }
+    end
+  end
+end

data/lib/relaton_bib/formatted_string.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "relaton_bib/localized_string"
+
+module RelatonBib
+  # Formatted string
+  class FormattedString < LocalizedString
+    FORMATS = %w[text/plain text/html application/docbook+xml
+                 application/tei+xml text/x-asciidoc text/markdown
+                 application/x-isodoc+xml].freeze
+
+    # @return [String]
+    attr_reader :format
+
+    # @param content [String]
+    # @param language [String] language code Iso639
+    # @param script [String] script code Iso15924
+    # @param format [String] the content type
+    def initialize(content:, language: nil, script: nil, format: nil)
+      # if format && !FORMATS.include?(format)
+        # raise ArgumentError, %{Format "#{format}" is invalid.}
+      # end
+
+      super(content, language, script)
+      @format = format
+    end
+
+    def to_xml(builder)
+      builder.parent["format"] = format if format
+      super
+    end
+  end
+end

data/lib/relaton_bib/localized_string.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RelatonBib
+  # Localized string.
+  class LocalizedString
+    # @return [Array<String>] language Iso639 code
+    attr_reader :language
+
+    # @return [Array<String>] script Iso15924 code
+    attr_reader :script
+
+    # @return [String]
+    attr_reader :content
+
+    # @param content [String]
+    # @param language [String] language code Iso639
+    # @param script [String] script code Iso15924
+    def initialize(content, language = nil, script = nil)
+      @language = []
+      @language << language if language
+      @script = []
+      @script << script if script
+      @content = content
+    end
+
+    # @return [String]
+    def to_s
+      content
+    end
+
+    # @return [TrueClass, FalseClass]
+    def empty?
+      content.empty?
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      return unless content
+
+      builder.parent["language"] = language.join(",") if language.any?
+      builder.parent["script"]   = script.join(",") if script.any?
+      builder.text content
+    end
+  end
+end