relaton-bib 0.1.0

data/lib/relaton_bib/medium.rb

@@ -0,0 +1,24 @@
+module RelatonBib
+  class Medium
+    # @return [String, NilClass]
+    attr_reader :form, :size, :scale
+
+    # @param form [String, NilClass]
+    # @param size [String, NilClass]
+    # @param scale [String, NilClass]
+    def initialize(form: nil, size: nil, scale: nil)
+      @form  = form
+      @size  = size
+      @scale = scale
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.medium do
+        builder.form form if form
+        builder.size size if size
+        builder.scale scale if scale
+      end
+    end
+  end
+end

data/lib/relaton_bib/organization.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "relaton_bib/contributor"
+
+module RelatonBib
+  # module OrgIdentifierType
+  #   ORCID = 'orcid'
+  #   URI   = 'uri'
+  # end
+
+  # Organization identifier.
+  class OrgIdentifier
+    ORCID = "orcid"
+    URI   = "uri"
+
+    # @return [String]
+    attr_reader :type
+
+    # @return [String]
+    attr_reader :value
+
+    # @param type [String] "orcid" or "uri"
+    # @param value [String]
+    def initialize(type, value)
+      unless [ORCID, URI].include? type
+        raise ArgumentError, 'Invalid type. It should be "orsid" or "uri".'
+      end
+
+      @type  = type
+      @value = value
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.identifier(value, type: type)
+    end
+  end
+
+  # Organization.
+  class Organization < Contributor
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :name
+
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :abbreviation
+
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :subdivision
+
+    # @return [Array<RelatonBib::OrgIdentifier>]
+    attr_reader :identifiers
+
+    def hash2locstr(name)
+      name.is_a?(Hash) ? LocalizedString.new(name[:content], name[:language], name[:script]) : LocalizedString.new(name)
+    end
+
+    # @param name [String, Array<String>]
+    # @param abbreviation [RelatoBib::LocalizedStrig, String]
+    # @param subdivision [RelatoBib::LocalizedStrig, String]
+    # @param url [String]
+    # @param identifiers [Array<RelatonBib::OrgIdentifier>]
+    # @param contacts [Array<RelatonBib::Address, RelatonBib::Phone>]
+    def initialize(**args)
+      raise ArgumentError, "missing keyword: name" unless args[:name]
+
+      super(url: args[:url], contacts: args.fetch(:contacts, []))
+
+      @name = if args[:name].is_a?(Array)
+                args[:name].map { |n| hash2locstr(n) }
+              else
+                [hash2locstr(args[:name])]
+              end
+
+      @abbreviation = if args[:abbreviation].is_a?(String)
+                        LocalizedString.new(args[:abbreviation])
+                      else
+                        args[:abbreviation]
+                      end
+
+      @subdivision  = if args[:subdivision].is_a?(String)
+                        LocalizedString.new(args[:subdivision])
+                      else
+                        args[:subdivision]
+                      end
+
+      @identifiers  = args.fetch(:identifiers, [])
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.organization do
+        name.each do |n|
+          builder.name { |b| n.to_xml b }
+        end
+        builder.subdivision { |s| subdivision.to_xml s } if subdivision
+        builder.abbreviation { |a| abbreviation.to_xml a } if abbreviation
+        builder.uri url if uri
+        identifiers.each { |identifier| identifier.to_xml builder }
+        super
+      end
+    end
+  end
+end

data/lib/relaton_bib/person.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "relaton_bib/contributor"
+
+module RelatonBib
+  # Person's full name
+  class FullName
+    # @return [Array<RelatonBib::LocalizedString>]
+    attr_accessor :forenames
+
+    # @return [Array<RelatonBib::LocalizedString>]
+    attr_accessor :initials
+
+    # @return [RelatonBib::LocalizedString]
+    attr_accessor :surname
+
+    # @return [Array<RelatonBib::LocalizedString>]
+    attr_accessor :additions
+
+    # @return [Array<RelatonBib::LocalizedString>]
+    attr_accessor :prefix
+
+    # @return [RelatonBib::LocalizedString]
+    attr_reader :completename
+
+    # @param surname [RelatonBib::LocalizedString]
+    # @param forenames [Array<RelatonBib::LocalizedString>]
+    # @param initials [Array<RelatonBib::LocalizedString>]
+    # @param additions [Array<RelatonBib::LocalizedString>]
+    # @param prefix [Array<RelatonBib::LocalizedString>]
+    # @param completename [RelatonBib::LocalizedString]
+    def initialize(**args)
+      unless args[:surname] || args[:completename]
+        raise ArgumentError, "Should be given :surname or :completename"
+      end
+
+      @surname      = args[:surname]
+      @forenames    = args.fetch :forenames, []
+      @initials     = args.fetch :initials, []
+      @additions    = args.fetch :additions, []
+      @prefix       = args.fetch :prefix, []
+      @completename = args[:completename]
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.name do
+        if completename
+          builder.completename { completename.to_xml builder }
+        else
+          prefix.each { |p| builder.prefix { p.to_xml builder } } 
+          initials.each { |i| builder.initial { i.to_xml builder } }
+          additions.each { |a| builder.addition { a.to_xml builder } }
+          builder.surname { surname.to_xml builder }
+          forenames.each { |f| builder.forename { f.to_xml builder } }
+        end
+      end
+    end
+  end
+
+  # Person identifier type.
+  module PersonIdentifierType
+    ISNI = "isni"
+    URI  = "uri"
+
+    # Checks type.
+    # @param type [String]
+    # @raise [ArgumentError] if type isn't "isni" or "uri"
+    def self.check(type)
+      unless [ISNI, URI].include? type
+        raise ArgumentError, 'Invalid type. It should be "isni" or "uri".'
+      end
+    end
+  end
+
+  # Person identifier.
+  class PersonIdentifier
+    # @return [RelatonBib::PersonIdentifierType::ISNI, RelatonBib::PersonIdentifierType::URI]
+    attr_accessor :type
+
+    # @return [String]
+    attr_accessor :value
+
+    # @param type [RelatonBib::PersonIdentifierType::ISNI, RelatonBib::PersonIdentifierType::URI]
+    # @param value [String]
+    def initialize(type, value)
+      PersonIdentifierType.check type
+
+      @type  = type
+      @value = value
+    end
+
+    # @param builser [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.identifier value, type: type
+    end
+  end
+
+  # Person class.
+  class Person < Contributor
+    # @return [RelatonBib::FullName]
+    attr_accessor :name
+
+    # @return [Array<RelatonBib::Affilation>]
+    attr_accessor :affiliation
+
+    # @return [Array<RelatonBib::PersonIdentifier>]
+    attr_accessor :identifiers
+
+    # @param name [RelatonBib::FullName]
+    # @param affiliation [Array<RelatonBib::Affiliation>]
+    # @param contacts [Array<RelatonBib::Address, RelatonBib::Phone>]
+    # @param identifiers [Array<RelatonBib::PersonIdentifier>]
+    def initialize(name:, affiliation: [], contacts: [], identifiers: [])
+      super(contacts: contacts)
+      @name        = name
+      @affiliation = affiliation
+      @identifiers = identifiers
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.person do
+        name.to_xml builder
+        affiliation.each { |a| a.to_xml builder }
+        identifiers.each { |id| id.to_xml builder }
+        contacts.each { |contact| contact.to_xml builder }
+      end
+    end
+  end
+end

data/lib/relaton_bib/series.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RelatonBib
+  #
+  # Series class.
+  #
+  class Series
+    TYPES = %w[main alt].freeze
+
+    # @return [String, NilClass] allowed values: "main" or "alt"
+    attr_reader :type
+
+    # @return [RelatonBib::FormattedRef, NilClass]
+    attr_reader :formattedref
+
+    # @return [RelatonBib::FormattedString, NilClass] title
+    attr_reader :title
+
+    # @return [String, NilClass]
+    attr_reader :place
+
+    # @return [String, NilClass]
+    attr_reader :organization
+
+    # @return [RelatonBib::LocalizedString, NilClass]
+    attr_reader :abbreviation
+
+    # @return [String, NilClass] date or year
+    attr_reader :from
+
+    # @return [String, NilClass] date or year
+    attr_reader :to
+
+    # @return [String, NilClass]
+    attr_reader :number
+
+    # @return [String, NilClass]
+    attr_reader :partnumber
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+    # @param type [String, NilClass] title or formattedref argument should be passed
+    # @param formattedref [RelatonBib::FormattedRef, NilClass]
+    # @param title [RelatonBib::TypedTitleString, NilClass]
+    # @param place [String, NilClass]
+    # @param orgaization [String, NilClass]
+    # @param abbreviation [RelatonBib::LocalizedString, NilClass]
+    # @param from [String, NilClass]
+    # @param to [String, NilClass]
+    # @param number [String, NilClass]
+    # @param partnumber [String, NilClass]
+    def initialize(**args)
+      unless args[:title].is_a?(RelatonBib::TypedTitleString) || args[:formattedref]
+        raise ArgumentError, "argument `title` or `formattedref` should present"
+      end
+
+      if args[:type] && !TYPES.include?(args[:type])
+        raise ArgumentError, "invalid argument `type`"
+      end
+
+      @type         = args[:type] # if %w[main alt].include? args[:type]
+      @title        = args[:title]
+      @formattedref = args[:formattedref]
+      @place        = args[:place]
+      @organization = args[:organization]
+      @abbreviation = args[:abbreviation]
+      @from         = args[:from]
+      @to           = args[:to]
+      @number       = args[:number]
+      @partnumber  = args[:partnumber]
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.series type: type do
+        if formattedref
+          formattedref.to_xml builder
+        else
+          builder.title { title.to_xml builder }
+          builder.place place if place
+          builder.organization organization if organization
+          builder.abbreviation { abbreviation.to_xml builder } if abbreviation
+          builder.from from if from
+          builder.to to if to
+          builder.number number if number
+          builder.partnumber partnumber if partnumber
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end

data/lib/relaton_bib/typed_title_string.rb

@@ -0,0 +1,41 @@
+module RelatonBib
+  class TypedTitleString
+    TITLE_TYPES = %w[alternative original unofficial subtitle main].freeze
+
+    # @return [String]
+    attr_reader :type
+
+    # @return [RelatonBib::FormattedString]
+    attr_reader :title
+
+    # @param type [String]
+    # @param title [RelatonBib::FormattedString, Hash]
+    # @param content [String]
+    # @param language [String]
+    # @param script [String]
+    def initialize(**args)
+      if args[:type] && !TITLE_TYPES.include?(args[:type])
+        raise ArgumentError, %{The type #{args[:type]} is invalid.}
+      end
+
+      unless args[:title] || args[:content]
+        raise ArgumentError, %{Keyword "title" or "content" should be passed.}
+      end
+
+      @type = args[:type]
+
+      # if args[:title]
+      #   @title = args[:title]
+      # else
+      fsargs = args.select { |k, _v| %i[content language script format].include? k }
+      @title = args.fetch :title, FormattedString.new(fsargs)
+      # end
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.parent[:type] = type if type
+      title.to_xml builder
+    end
+  end
+end

data/lib/relaton_bib/typed_uri.rb

@@ -0,0 +1,20 @@
+module RelatonBib
+  # Typed URI
+  class TypedUri
+    # @return [Symbol] :src/:obp/:rss
+    attr_reader :type
+    # @retutn [URI]
+    attr_reader :content
+
+    # @param type [String] src/obp/rss
+    # @param content [String]
+    def initialize(type:, content:)
+      @type    = type
+      @content = URI content if content
+    end
+
+    def to_xml(builder)
+      builder.uri(content.to_s, type: type)
+    end
+  end
+end

data/lib/relaton_bib/validity.rb

@@ -0,0 +1,31 @@
+module RelatonBib
+  class Validity
+    # @return [Time, NilClass]
+    attr_reader :begins
+
+    # @return [Time, NilClass]
+    attr_reader :ends
+
+    # @return [Time, NilClass]
+    attr_reader :revision
+
+    # @param begins [Time, NilClass]
+    # @param ends [Time, NilClass]
+    # @param revision [Time, NilClass]
+    def initialize(begins: nil, ends: nil, revision: nil)
+      @begins   = begins
+      @ends     = ends
+      @revision = revision
+    end
+
+    # @param [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      format = "%Y-%m-%d %H:%M"
+      builder.validity do
+        builder.validityBegins begins.strftime(format) if begins
+        builder.validityEnds ends.strftime(format) if ends
+        builder.validityRevision revision.strftime(format) if revision
+      end
+    end
+  end
+end