relaton-bib 1.4.0 → 2.1.7

data/lib/relaton_bib/bibtex_parser.rb

@@ -1,245 +0,0 @@
-require "bibtex"
-require "iso639"
-
-module RelatonBib
-  class BibtexParser
-    class << self
-      # @param bibtex [String]
-      # @return [Hash{String=>RelatonBib::BibliographicItem}]
-      def from_bibtex(bibtex)
-        BibTeX.parse(bibtex).reduce({}) do |h, bt|
-          h[bt.key] = BibliographicItem.new(
-            id: bt.key,
-            docid: fetch_docid(bt),
-            fetched: fetch_fetched(bt),
-            type: fetch_type(bt),
-            title: fetch_title(bt),
-            contributor: fetch_contributor(bt),
-            date: fetch_date(bt),
-            place: fetch_place(bt),
-            biblionote: fetch_note(bt),
-            relation: fetch_relation(bt),
-            extent: fetch_extent(bt),
-            edition: bt["edition"]&.to_s,
-            series: fetch_series(bt),
-            link: fetch_link(bt),
-            language: fetch_language(bt),
-            classification: fetch_classification(bt),
-            keyword: fetch_keyword(bt)
-          )
-          h
-        end
-      end
-
-      private
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::DocumentIdentifier>]
-      def fetch_docid(bibtex)
-        docid = []
-        docid << DocumentIdentifier.new(id: bibtex.isbn.to_s, type: "isbn") if bibtex["isbn"]
-        docid << DocumentIdentifier.new(id: bibtex.lccn.to_s, type: "lccn") if bibtex["lccn"]
-        docid << DocumentIdentifier.new(id: bibtex.issn.to_s, type: "issn") if bibtex["issn"]
-        docid
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [String, NilClass]
-      def fetch_fetched(bibtex)
-        Date.parse(bibtex.timestamp.to_s) if bibtex["timestamp"]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [String]
-      def fetch_type(bibtex)
-        case bibtex.type
-        when :mastersthesis, :phdthesis then "thesis"
-        when :conference then "inproceedings"
-        when :misc then "standard"
-        else bibtex.type.to_s
-        end
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_place(bibtex)
-        bibtex["address"] ? [bibtex.address.to_s] : []
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_title(bibtex)
-        title = []
-        title << { type: "main", content: bibtex.title.to_s } if bibtex["title"]
-        title << { type: "main", content: bibtex.subtitle.to_s } if bibtex["subtitle"]
-        title
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_contributor(bibtex)
-        contributor = []
-        fetch_person(bibtex["author"]).each do |entity|
-          contributor << { entity: entity, role: [{ type: "author" }] }
-        end
-
-        fetch_person(bibtex["editor"]).each do |entity|
-          contributor << { entity: entity, role: [{ type: "editor" }] }
-        end
-
-        if bibtex["publisher"]
-          contributor << { entity: { name: bibtex.publisher.to_s }, role: [{ type: "publisher" }] }
-        end
-
-        if bibtex["institution"]
-          contributor << {
-            entity: { name: bibtex.institution.to_s },
-            role: [{ type: "distributor", description: ["sponsor"] }]
-          }
-        end
-
-        if bibtex["organization"]
-          contributor << {
-            entity: { name: bibtex.organization.to_s },
-            role: [{ type: "distributor", description: ["sponsor"] }]
-          }
-        end
-
-        if bibtex["school"]
-          contributor << {
-            entity: { name: bibtex.school.to_s },
-            role: [{ type: "distributor", description: ["sponsor"] }]
-          }
-        end
-        contributor
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::Person>]
-      def fetch_person(person)
-        return [] unless person
-
-        person.map do |name|
-          parts = name.split ", "
-          surname = LocalizedString.new parts.first
-          fname = parts.size > 1 ? parts[1].split : []
-          forename = fname.map { |fn| LocalizedString.new fn }
-          Person.new name: FullName.new(surname: surname, forename: forename)
-        end
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_date(bibtex)
-        date = []
-        if bibtex["year"]
-          on = Date.new(bibtex.year.to_i, bibtex["month_numeric"]&.to_i || 1).to_s
-          date << { type: "published", on: on }
-        end
-
-        if bibtex["urldate"]
-          date << { type: "accessed", on: Date.parse(bibtex.urldate.to_s).to_s }
-        end
-
-        date
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::BiblioNote>]
-      def fetch_note(bibtex)
-        bibtex.select do |k, _v|
-          %i[annote howpublished comment note content].include? k
-        end.reduce([]) do |mem, note|
-          type = case note[0]
-                 when :note then nil
-                 when :content then "tableOfContents"
-                 else note[0].to_s
-                 end
-          mem << BiblioNote.new(type: type, content: note[1].to_s)
-        end
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_relation(bibtex)
-        return [] unless bibtex["booktitle"]
-
-        title = TypedTitleString.new(type: "main", content: bibtex.booktitle.to_s)
-        [{ type: "partOf", bibitem: BibliographicItem.new(title: [title]) }]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::BibItemLocality>]
-      def fetch_extent(bibtex)
-        bibtex.select do |k, _v|
-          %i[chapter pages volume].include? k
-        end.reduce([]) do |mem, loc|
-          if loc[0] == :pages
-            type = "page"
-            from, to = loc[1].to_s.split "-"
-          else
-            type = loc[0].to_s
-            from = loc[1].to_s
-            to = nil
-          end
-          mem << BibItemLocality.new(type, from, to)
-        end
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::Series>]
-      def fetch_series(bibtex)
-        series = []
-        if bibtex["journal"]
-          series << Series.new(
-            type: "journal",
-            title: TypedTitleString.new(content: bibtex.journal.to_s),
-            number: bibtex["number"]&.to_s,
-          )
-        end
-
-        if bibtex["series"]
-          title = TypedTitleString.new content: bibtex.series.to_s
-          series << Series.new(title: title)
-        end
-        series
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::TypedUri>]
-      def fetch_link(bibtex)
-        link = []
-        link << TypedUri.new(type: "src", content: bibtex.url.to_s) if bibtex["url"]
-        link << TypedUri.new(type: "doi", content: bibtex.doi.to_s) if bibtex["doi"]
-        link << TypedUri.new(type: "file", content: bibtex.file2.to_s) if bibtex["file2"]
-        link
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<String>]
-      def fetch_language(bibtex)
-        return [] unless bibtex["language"]
-
-        [Iso639[bibtex.language.to_s].alpha2]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [RelatonBib::Classification, NilClass]
-      def fetch_classification(bibtex)
-        cls = []
-        cls << Classification.new(type: "type", value: bibtex["type"].to_s) if bibtex["type"]
-        # cls << Classification.new(type: "keyword", value: bibtex.keywords.to_s) if bibtex["keywords"]
-        if bibtex["mendeley-tags"]
-          cls << Classification.new(type: "mendeley", value: bibtex["mendeley-tags"].to_s)
-        end
-        cls
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<String>]
-      def fetch_keyword(bibtex)
-        bibtex["keywords"]&.split(", ") || []
-      end
-    end
-  end
-end

data/lib/relaton_bib/classification.rb

@@ -1,40 +0,0 @@
-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
-
-    # @return [Hash]
-    def to_hash
-      hash = { "value" => value }
-      hash["type"] = type if type
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of classifications
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1)
-      pref = prefix.empty? ? "classification" : prefix + ".classification"
-      out = count > 1 ? "#{pref}::\n" : ""
-      out += "#{pref}.type:: #{type}\n" if type
-      out += "#{pref}.value:: #{value}\n"
-      out
-    end
-  end
-end

data/lib/relaton_bib/contribution_info.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require "relaton_bib/person"
-
-# RelatonBib module
-module RelatonBib
-  # Contributor's role.
-  class ContributorRole
-    include RelatonBib
-
-    TYPES = %w[author performer publisher editor adapter translator
-               distributor].freeze
-
-    # @return [Array<RelatonBib::FormattedString>]
-    attr_reader :description
-
-    # @return [Strig]
-    attr_reader :type
-
-    # @param type [String] allowed types "author", "editor",
-    #   "cartographer", "publisher"
-    # @param description [Array<String>]
-    def initialize(**args)
-      if args[:type] && !TYPES.include?(args[:type])
-        warn %{[relaton-bib] Contributor's type "#{args[:type]}" is invalid.}
-      end
-
-      @type = args[:type]
-      @description = args.fetch(:description, []).map do |d|
-        FormattedString.new content: d, format: nil
-      end
-    end
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      builder.role(type: type) do
-        description.each do |d|
-          builder.description { |desc| d.to_xml(desc) }
-        end
-      end
-    end
-
-    # @return [Hash, String]
-    def to_hash
-      if description&.any?
-        hash = { "description" => single_element_array(description) }
-        hash["type"] = type if type
-        hash
-      elsif type
-        type
-      end
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of contributors
-    # 2return [String]
-    def to_asciibib(prefix = "", count = 1)
-      pref = prefix.empty? ? prefix : prefix + "."
-      out = count > 1 ? "#{prefix}::\n" : ""
-      description.each do |d|
-        out += d.to_asciibib "#{pref}role.description", description.size
-      end
-      out += "#{pref}role.type:: #{type}\n" if type
-      out
-    end
-  end
-
-  # Contribution info.
-  class ContributionInfo
-    include RelatonBib
-
-    # @return [Array<RelatonBib::ContributorRole>]
-    attr_reader :role
-
-    # @return
-    #   [RelatonBib::Person, RelatonBib::Organization]
-    attr_reader :entity
-
-    # @param entity [RelatonBib::Person, RelatonBib::Organization]
-    # @param role [Array<String>]
-    def initialize(entity:, role: [{ type: "publisher" }])
-      @entity = entity
-      @role   = role.map { |r| ContributorRole.new(**r) }
-    end
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      entity.to_xml builder
-    end
-
-    # @return [Hash]
-    def to_hash
-      hash = entity.to_hash
-      hash["role"] = single_element_array(role) if role&.any?
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of contributors
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1)
-      pref = prefix.split(".").first
-      out = count > 1 ? "#{pref}::\n" : ""
-      out += entity.to_asciibib prefix
-      role.each { |r| out += r.to_asciibib pref, role.size }
-      out
-    end
-  end
-end

data/lib/relaton_bib/contributor.rb

@@ -1,215 +0,0 @@
-# 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
-
-    # @return [Hash]
-    def to_hash
-      hash = {}
-      hash["street"] = street if street&.any?
-      hash["city"] = city
-      hash["state"] = state if state
-      hash["country"] = country
-      hash["postcode"] = postcode if postcode
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of addresses
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize
-      pref = prefix.empty? ? "address" : prefix + ".address"
-      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
-
-  # Contact class.
-  class Contact
-    # @return [String] allowed "phone", "email" or "uri"
-    attr_reader :type
-
-    # @return [String]
-    attr_reader :value
-
-    # @param type [String] allowed "phone", "email" or "uri"
-    # @param value [String]
-    def initialize(type:, value:)
-      @type  = type
-      @value = value
-    end
-
-    # @param builder [Nokogiri::XML::Document]
-    def to_xml(doc)
-      doc.send type, value
-    end
-
-    # @return [Hash]
-    def to_hash
-      { "type" => type, "value" => value }
-    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:: #{type}\n"
-      out += "#{pref}contact.value:: #{value}\n"
-      out
-    end
-  end
-
-  # Affiliation.
-  class Affiliation
-    include RelatonBib
-
-    # @return [RelatonBib::LocalizedString, NilClass]
-    attr_reader :name
-
-    # @return [Array<RelatonBib::FormattedString>]
-    attr_reader :description
-
-    # @return [RelatonBib::Organization]
-    attr_reader :organization
-
-    # @param organization [RelatonBib::Organization]
-    # @param name [RelatonBib::LocalizedString, NilClass]
-    # @param description [Array<RelatonBib::FormattedString>]
-    def initialize(organization:, name: nil, description: [])
-      @name = name
-      @organization = organization
-      @description  = 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
-
-    # @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)
-      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.*"
-      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, NilClass]
-    # @param contact [Array<RelatonBib::Address, RelatonBib::Contact>]
-    def initialize(url: nil, contact: [])
-      @uri = URI url if url
-      @contact = 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,77 +0,0 @@
-module RelatonBib
-  # Copyright association.
-  class CopyrightAssociation
-    include RelatonBib
-
-    # @return [Date]
-    attr_reader :from
-
-    # @return [Date, NilClass]
-    attr_reader :to
-
-    # @return [String, NilClass]
-    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, NilClass] date
-    # @param scope [String, NilClass]
-    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 builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      builder.copyright do
-        builder.from from ? from.year : "unknown"
-        builder.to to.year if to
-        owner.each { |o| builder.owner { o.to_xml builder } }
-        builder.scope scope if scope
-      end
-    end
-    # rubocop:enable Metrics/AbcSize
-
-    # @return [Hash]
-    def to_hash
-      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