relaton-bib 1.20.8 → 2.0.0

data/lib/relaton_bib/contributor.rb

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module RelatonBib
-  # Address class.
-  class Address
-    # @return [Array<String>]
-    attr_reader :street
-
-    # @return [String, nil]
-    attr_reader :city, :state, :country, :postcode, :formatted_address
-
-    # @param street [Array<String>] streets
-    # @param city [String, nil] city, should be present or formatted address provided
-    # @param state [String, nil] state
-    # @param country [String, nil] country, should be present or formatted address provided
-    # @param postcode [String, nil] postcode
-    # @param formatted_address [String, nil] formatted address, should be present or city and country provided
-    def initialize(**args) # rubocop:disable Metrics/CyclomaticComplexity
-      unless args[:formatted_address] || (args[:city] && args[:country])
-        raise ArgumentError, "Either formatted address or city and country must be provided"
-      end
-
-      @street   = args[:street] || []
-      @city     = args[:city]
-      @state    = args[:state]
-      @country  = args[:country]
-      @postcode = args[:postcode]
-      @formatted_address = args[:formatted_address] unless args[:city] && args[:country]
-    end
-
-    def ==(other)
-      street == other.street && city == other.city && state == other.state &&
-        country == other.country && postcode == other.postcode &&
-        formatted_address == other.formatted_address
-    end
-
-    # @param doc [Nokogiri::XML::Document]
-    def to_xml(doc) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      doc.address do
-        if formatted_address
-          doc.formattedAddress formatted_address
-        else
-          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
-
-    # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      hash = { "address" => {} }
-      if formatted_address
-        hash["address"]["formatted_address"] = formatted_address
-      else
-        hash["address"]["street"] = street if street.any?
-        hash["address"]["city"] = city
-        hash["address"]["state"] = state if state
-        hash["address"]["country"] = country
-        hash["address"]["postcode"] = postcode if postcode
-      end
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of addresses
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      pref = prefix.empty? ? "address" : "#{prefix}.address"
-      if formatted_address
-        "#{pref}.formatted_address:: #{formatted_address}\n"
-      else
-        out = count > 1 ? "#{pref}::\n" : ""
-        street.each { |st| out += "#{pref}.street:: #{st}\n" }
-        out += "#{pref}.city:: #{city}\n"
-        out += "#{pref}.state:: #{state}\n" if state
-        out += "#{pref}.country:: #{country}\n"
-        out += "#{pref}.postcode:: #{postcode}\n" if postcode
-        out
-      end
-    end
-  end
-
-  # Contact class.
-  class Contact
-    # @return [String] allowed "phone", "email" or "uri"
-    attr_reader :type
-
-    # @return [String, nil]
-    attr_reader :subtype
-
-    # @return [String]
-    attr_reader :value
-
-    # @param type [String] allowed "phone", "email" or "uri"
-    # @param subtype [String, nil] i.e. "fax", "mobile", "landline" for "phone"
-    #                              or "work", "personal" for "uri" type
-    # @param value [String]
-    def initialize(type:, value:, subtype: nil)
-      @type     = type
-      @subtype  = subtype
-      @value    = value
-    end
-
-    def ==(other)
-      type == other.type && subtype == other.subtype && value == other.value
-    end
-
-    # @param builder [Nokogiri::XML::Document]
-    def to_xml(builder)
-      node = builder.send type, value
-      node["type"] = subtype if subtype
-    end
-
-    # @return [Hash]
-    def to_hash
-      hash = { type => value }
-      hash["type"] = subtype if subtype
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of contacts
-    # @return [string]
-    def to_asciibib(prefix = "", count = 1)
-      pref = prefix.empty? ? prefix : "#{prefix}."
-      out = count > 1 ? "#{pref}contact::\n" : ""
-      out += "#{pref}contact.#{type}:: #{value}\n"
-      out += "#{pref}contact.type:: #{subtype}\n" if subtype
-      out
-    end
-  end
-
-  # Affiliation.
-  class Affiliation
-    include RelatonBib
-
-    # @return [RelatonBib::LocalizedString, nil]
-    attr_reader :name
-
-    # @return [RelatonBib::Organization]
-    attr_reader :organization
-
-    # @param organization [RelatonBib::Organization, nil]
-    # @param name [RelatonBib::LocalizedString, nil]
-    # @param description [Array<RelatonBib::FormattedString>]
-    def initialize(organization: nil, name: nil, description: [])
-      @name = name
-      @organization = organization
-      @description  = description
-    end
-
-    def ==(other)
-      name == other.name && organization == other.organization && description == other.description
-    end
-
-    # @param opts [Hash]
-    # @option opts [Nokogiri::XML::Builder] :builder XML builder
-    # @option opts [String] :lang language
-    def to_xml(**opts)
-      return unless organization || name || description&.any?
-
-      opts[:builder].affiliation do |builder|
-        name_xml builder
-        description_xml builder
-        organization&.to_xml(**opts)
-      end
-    end
-
-    def name_xml(builder)
-      builder.name { name.to_xml builder } if name
-    end
-
-    def description_xml(builder)
-      description.each { |d| builder.description { d.to_xml builder } }
-    end
-
-    #
-    # Get description.
-    #
-    # @param [String, nil] lang language if nil return all description
-    #
-    # @return return [Array<RelatonBib::FormattedString>] description
-    #
-    def description(lang = nil)
-      return @description unless lang
-
-      @description.select { |d| d.language&.include? lang }
-    end
-
-    #
-    # Render affiliation as hash.
-    #
-    # @return [Hash]
-    #
-    def to_hash
-      hash = organization&.to_hash || {}
-      hash["name"] = name.to_hash if name
-      if description&.any?
-        hash["description"] = single_element_array(description)
-      end
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer]
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize
-      pref = prefix.empty? ? prefix : "#{prefix}."
-      out = count > 1 ? "#{pref}affiliation::\n" : ""
-      out += name.to_asciibib "#{pref}affiliation.name" if name
-      description.each do |d|
-        out += d.to_asciibib "#{pref}affiliation.description", description.size
-      end
-      out += organization.to_asciibib "#{pref}affiliation.*" if organization
-      out
-    end
-  end
-
-  # Contributor.
-  class Contributor
-    include RelatonBib
-
-    # @return [URI]
-    attr_reader :uri
-
-    # @return [Array<RelatonBib::Address, RelatonBib::Contact>]
-    attr_reader :contact
-
-    # @param url [String, nil]
-    # @param contact [Array<RelatonBib::Address, RelatonBib::Contact>]
-    def initialize(url: nil, contact: [])
-      @uri = URI url if url
-      @contact = contact
-    end
-
-    def ==(other)
-      uri == other.uri && contact == other.contact
-    end
-
-    # Returns url.
-    # @return [String]
-    def url
-      @uri.to_s
-    end
-
-    # @params builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      contact.each { |contact| contact.to_xml builder }
-    end
-
-    # @return [Hash]
-    def to_hash
-      hash = {}
-      hash["url"] = uri.to_s if uri
-      hash["contact"] = single_element_array(contact) if contact&.any?
-      hash
-    end
-
-    # @param prefix [String]
-    # @return [String]
-    def to_asciibib(prefix = "") # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      pref = prefix.empty? ? prefix : "#{prefix}."
-      out = ""
-      out += "#{pref}url:: #{uri}\n" if uri
-      addr = contact.select { |c| c.is_a? RelatonBib::Address }
-      addr.each { |ct| out += ct.to_asciibib prefix, addr.size }
-      cont = contact.select { |c| c.is_a? RelatonBib::Contact }
-      cont.each { |ct| out += ct.to_asciibib prefix, cont.size }
-      out
-    end
-  end
-end

data/lib/relaton_bib/copyright_association.rb

@@ -1,79 +0,0 @@
-module RelatonBib
-  # Copyright association.
-  class CopyrightAssociation
-    include RelatonBib
-
-    # @return [Date]
-    attr_reader :from
-
-    # @return [Date, nil]
-    attr_reader :to
-
-    # @return [String, nil]
-    attr_reader :scope
-
-    # @return [Array<RelatonBib::ContributionInfo>]
-    attr_reader :owner
-
-    # rubocop:disable Metrics/AbcSize
-
-    # @param owner [Array<Hash, RelatonBib::ContributionInfo>] contributor
-    # @option owner [String] :name
-    # @option owner [String] :abbreviation
-    # @option owner [String] :url
-    # @param from [String] date
-    # @param to [String, nil] date
-    # @param scope [String, nil]
-    def initialize(owner:, from:, to: nil, scope: nil)
-      unless owner.any?
-        raise ArgumentError, "at least one owner should exist."
-      end
-
-      @owner = owner.map do |o|
-        o.is_a?(Hash) ? ContributionInfo.new(entity: Organization.new(**o)) : o
-      end
-
-      @from  = Date.strptime(from.to_s, "%Y") if from.to_s.match?(/\d{4}/)
-      @to    = Date.strptime(to.to_s, "%Y") unless to.to_s.empty?
-      @scope = scope
-    end
-
-    # @param opts [Hash]
-    # @option opts [Nokogiri::XML::Builder] :builder XML builder
-    # @option opts [String, Symbol] :lang language
-    def to_xml(**opts)
-      opts[:builder].copyright do |builder|
-        builder.from from ? from.year : "unknown"
-        builder.to to.year if to
-        owner.each { |o| builder.owner { o.to_xml(**opts) } }
-        builder.scope scope if scope
-      end
-    end
-    # rubocop:enable Metrics/AbcSize
-
-    # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize
-      owners = single_element_array(owner.map { |o| o.to_hash["organization"] })
-      hash = {
-        "owner" => owners,
-        "from" => from.year.to_s,
-      }
-      hash["to"] = to.year.to_s if to
-      hash["scope"] = scope if scope
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Iteger] number of copyright elements
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      pref = prefix.empty? ? "copyright" : "#{prefix}.copyright"
-      out = count > 1 ? "#{pref}::\n" : ""
-      owner.each { |ow| out += ow.to_asciibib "#{pref}.owner", owner.size }
-      out += "#{pref}.from:: #{from.year}\n" if from
-      out += "#{pref}.to:: #{to.year}\n" if to
-      out += "#{pref}.scope:: #{scope}\n" if scope
-      out
-    end
-  end
-end

data/lib/relaton_bib/deep_dup.rb

@@ -1,30 +0,0 @@
-class Object
-  def duplicable?
-    true
-  end
-
-  def deep_dup
-    duplicable? ? dup : self
-  end
-end
-
-class Array
-  def deep_dup
-    map(&:deep_dup)
-  end
-end
-
-# class Hash
-#   def deep_dup
-#     hash = dup
-#     each_pair do |key, value|
-#       if key.frozen? && ::String === key
-#         hash[key] = value.deep_dup
-#       else
-#         hash.delete(key)
-#         hash[key.deep_dup] = value.deep_dup
-#       end
-#     end
-#     hash
-#   end
-# end

data/lib/relaton_bib/document_identifier.rb

@@ -1,118 +0,0 @@
-module RelatonBib
-  # Document identifier.
-  class DocumentIdentifier
-    # @return [String]
-    attr_reader :id
-
-    # @return [String, nil]
-    attr_reader :type, :scope, :language, :script
-
-    # @param type [Boolean, nil]
-    attr_reader :primary
-
-    # @param id [String]
-    # @param type [String, nil]
-    # @param scope [String, nil]
-    # @param primary [Bolean, nil]
-    # @param language [String, nil]
-    def initialize(**args)
-      @id       = args[:id]
-      @type     = args[:type]
-      @scope    = args[:scope]
-      @primary  = args[:primary]
-      @language = args[:language]
-      @script   = args[:script]
-    end
-
-    # in docid manipulations, assume ISO as the default: id-part:year
-    def remove_part
-      case @type
-      when "Chinese Standard" then @id.sub!(/\.\d+/, "")
-      when "URN" then remove_urn_part
-      else @id.sub!(/-[^:]+/, "")
-      end
-    end
-
-    def remove_date
-      case @type
-      when "Chinese Standard" then @id.sub!(/-[12]\d\d\d/, "")
-      when "URN"
-        @id.sub!(/^(urn:iec:std:[^:]+:[^:]+:)[^:]*/, '\1')
-      else @id.sub!(/:[12]\d\d\d/, "")
-      end
-    end
-
-    def all_parts
-      if type == "URN"
-        @id.sub!(%r{^(urn:iec:std(?::[^:]*){4}).*}, '\1:ser')
-      else
-        @id += " (all parts)"
-      end
-    end
-
-    #
-    # Add docidentifier xml element
-    #
-    # @param opts [Hash]
-    # @option opts [Nokogiri::XML::Builder] :builder XML builder
-    # @option opts [String] :lang language
-    def to_xml(**opts) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      lid = if type == "URN" && opts[:lang]
-              id.sub %r{(?<=:)(?:\w{2},)*?(#{opts[:lang]})(?:,\w{2})*}, '\1'
-            else id
-            end
-      element = opts[:builder].docidentifier { |b| b.parent.inner_html = lid }
-      element[:type] = type if type
-      element[:scope] = scope if scope
-      element[:primary] = primary if primary
-      element[:language] = language if language
-      element[:script] = script if script
-    end
-
-    # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize
-      hash = { "id" => id }
-      hash["type"] = type if type
-      hash["scope"] = scope if scope
-      hash["primary"] = primary if primary
-      hash["language"] = language if language
-      hash["script"] = script if script
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of docids
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
-      pref = prefix.empty? ? prefix : "#{prefix}."
-      return "#{pref}docid:: #{id}\n" unless type || scope
-
-      out = count > 1 ? "#{pref}docid::\n" : ""
-      out += "#{pref}docid.type:: #{type}\n" if type
-      out += "#{pref}docid.scope:: #{scope}\n" if scope
-      out += "#{pref}docid.primary:: #{primary}\n" if primary
-      out += "#{pref}docid.language:: #{language}\n" if language
-      out += "#{pref}docid.script:: #{script}\n" if script
-      out + "#{pref}docid.id:: #{id}\n"
-    end
-
-    private
-
-    def remove_urn_part # rubocop:disable Metrics/MethodLength
-      @id.sub!(%r{^
-        (urn:iso:std:[^:]+ # ISO prefix and originator
-          (?::(?:data|guide|isp|iwa|pas|r|tr|ts|tta)) # type
-          ?:\d+) # docnumber
-        (?::-[^:]+)? # partnumber
-        (?::(draft|cancelled|stage-[^:]+))? # status
-        (?::ed-\d+)?(?::v[^:]+)? # edition and version
-        (?::\w{2}(?:,\w{2})*)? # langauge
-      }x, '\1') # remove partnumber, status, version, and language
-      @id.sub!(%r{^
-        (urn:iec:std:[^:]+ # IEC prefix and originator
-          :\d+) # docnumber
-        (?:-[^:]+)? # partnumber
-      }x, '\1') # remove partnumber
-    end
-  end
-end

data/lib/relaton_bib/document_relation.rb

@@ -1,95 +0,0 @@
-module RelatonBib
-  # Documett relation
-  class DocumentRelation
-    include RelatonBib
-
-    TYPES = %w[
-      includes includedIn hasPart partOf merges mergedInto splits splitInto
-      instanceOf hasInstance exemplarOf hasExemplar manifestationOf
-      hasManifestation reproductionOf hasReproduction reprintOf hasReprint
-      expressionOf hasExpression translatedFrom hasTranslation arrangementOf
-      hasArrangement abridgementOf hasAbridgement annotationOf hasAnnotation
-      draftOf hasDraft editionOf hasEdition updates updatedBy derivedFrom
-      derives describes describedBy catalogues cataloguedBy hasSuccessor
-      successorOf adaptedFrom hasAdaptation adoptedFrom adoptedAs reviewOf
-      hasReview commentaryOf hasCommentary related hasComplement complementOf
-      obsoletes obsoletedBy cites isCitedIn
-    ].freeze
-
-    # @return [String]
-    attr_accessor :type
-
-    # @return [RelatonBib::FormattedString, nil]
-    attr_reader :description
-
-    # @return [String]
-    # attr_reader :identifier, :url
-
-    # @return [RelatonBib::BibliographicItem]
-    attr_reader :bibitem
-
-    # @return [Array<RelatonBib::Locality, RelatonBib::LocalityStack>]
-    attr_reader :locality
-
-    # @return [Array<RelatonBib::SourceLocality,
-    #   RelatonBib::SourceLocalityStack>]
-    attr_reader :source_locality
-
-    # @param type [String]
-    # @param description [RelatonBib::FormattedString, nil]
-    # @param bibitem [RelatonBib::BibliographicItem,
-    #   RelatonIso::IsoBibliographicItem]
-    # @param locality [Array<RelatonBib::Locality>]
-    # @param locality_stack [Array<RelatonBib::LocalityStack>]
-    # @param source_locality [Array<RelatonBib::SourceLocality,
-    #   RelatonBib::SourceLocalityStack>]
-    def initialize(type:, bibitem:, **args)
-      type = "obsoletes" if type == "Now withdrawn"
-      unless self.class::TYPES.include? type
-        Util.warn "Invalid relation type: `#{type}`"
-      end
-      @type = type
-      @description = args[:description]
-      @locality = args[:locality] || args[:locality_stack] || []
-      @source_locality = args[:source_locality] || args[:source_locality_stack] || []
-      @bibitem = bibitem
-    end
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder, **opts)
-      opts.delete :bibdata
-      opts.delete :note
-      builder.relation(type: type) do
-        builder.description { description.to_xml builder } if description
-        bibitem.to_xml(**opts.merge(builder: builder, embedded: true))
-        locality.each { |l| l.to_xml builder }
-        source_locality.each { |l| l.to_xml builder }
-      end
-    end
-
-    # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize
-      hash = { "type" => type, "bibitem" => bibitem.to_hash(embedded: true) }
-      hash["description"] = description.to_hash if description
-      locality.each_with_object(hash) do |l, obj|
-        k, v = l.to_hash.first
-        hash[k] ||= []
-        hash[k] << v
-      end
-      if source_locality&.any?
-        hash["source_locality"] = single_element_array(source_locality)
-      end
-      hash
-    end
-
-    # @param prefix [String]
-    # @return [String]
-    def to_asciibib(prefix = "")
-      pref = prefix.empty? ? prefix : prefix + "."
-      out = "#{prefix}.type:: #{type}\n"
-      out += description.to_asciibib "#{pref}desctiption" if description
-      out += bibitem.to_asciibib "#{pref}bibitem" if bibitem
-      out
-    end
-  end
-end

data/lib/relaton_bib/document_relation_collection.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RelatonBib
-  # Document relation collection
-  class DocRelationCollection
-    extend Forwardable
-
-    def_delegators :@array, :<<, :[], :first, :last, :empty?, :any?, :size,
-                   :each, :detect, :map, :reduce, :length, :unshift, :max_by
-
-    # @param relation [Array<RelatonBib::DocumentRelation, Hash>]
-    # @option relation [String] :type
-    # @option relation [String] :identifier
-    # @option relation [String, NIllClass] :url (nil)
-    # @option relation [Array<RelatonBib::Locality, RelatonBib::LocalityStack>] :locality
-    # @option relation [Array<RelatonBib::SourceLocality, RelatonBib::SourceLocalityStack>] :source_locality
-    # @option relation [RelatonBib::BibliographicItem, nil] :bibitem (nil)
-    def initialize(relation)
-      @array = relation.map { |r| r.is_a?(Hash) ? DocumentRelation.new(**r) : r }
-    end
-
-    #
-    # Returns new DocumentRelationCollection with selected relations.
-    #
-    # @example Select relations with type "obsoletes"
-    #   relations.select { |r| r.type == "obsoletes" }
-    #   #=> <RelatonBib::DocRelationCollection:0x00007f9a0191d5f0 @array=[...]>
-    #
-    # @return [RelatonBib::DocRelationCollection] new DocumentRelationCollection
-    #   with selected relations
-    #
-    def select(&block)
-      arr = @array.select(&block)
-      self.class.new arr
-    end
-
-    # @todo We don't have replace type anymore. Suppose we should update this
-    #   method or delete it.
-    #
-    # @return [RelatonBib::DocRelationCollection]
-    def replaces
-      DocRelationCollection.new(@array.select { |r| r.type == "replace" })
-    end
-
-    # @param prefix [String]
-    # @return [String]
-    def to_asciibib(prefix = "")
-      pref = prefix.empty? ? "relation" : "#{prefix}.relation"
-      out = ""
-      @array.each do |r|
-        out += size > 1 ? "#{pref}::\n" : ""
-        out += r.to_asciibib pref
-      end
-      out
-    end
-  end
-end