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

data/lib/relaton/bibtex_parser.rb

@@ -1,243 +0,0 @@
-module Relaton
-  # @todo: move this class to the Relaton::Bib::Bibtex module
-  class BibtexParser
-    class << self
-      # @param bibtex [String]
-      # @return [Hash{String=>Relaton::Bib::Item}]
-      def from_bibtex(bibtex) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        BibTeX.parse(bibtex).reduce({}) do |h, bt|
-          h[bt.key] = Item.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<Relaton::Bib::Docidentifier>]
-      def fetch_docid(bibtex) # rubocop:disable Metrics/AbcSize
-        docid = []
-        docid << Docidentifier.new(id: bibtex.isbn.to_s, type: "isbn") if bibtex["isbn"]
-        docid << Docidentifier.new(id: bibtex.lccn.to_s, type: "lccn") if bibtex["lccn"]
-        docid << Docidentifier.new(id: bibtex.issn.to_s, type: "issn") if bibtex["issn"]
-        docid
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [String, nil]
-      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 [Relaton::Bib::TitleCollection]
-      def fetch_title(bibtex)
-        title = []
-        title << { type: "main", content: bibtex.convert(:latex).title.to_s } if bibtex["title"]
-        title << { type: "main", content: bibtex.convert(:latex).subtitle.to_s } if bibtex["subtitle"]
-        TitleCollection.new title
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Hash>]
-      def fetch_contributor(bibtex) # rubocop:disable Metrics/AbcSize
-        contribs = []
-        fetch_person(bibtex, "author") { |author| contribs << author }
-        fetch_person(bibtex, "editor") { |editor| contribs << editor }
-
-        fetch_org(bibtex["publisher"], "publisher") { |pub| contribs << pub }
-        fetch_org(bibtex["institution"], "distributor", "sponsor") { |distr| contribs << distr }
-        fetch_org(bibtex["organization"], "distributor", "sponsor") { |org| contribs << org }
-        fetch_org(bibtex["school"], "distributor", "sponsor") { |school| contribs << school }
-
-        fetch_howpublished(bibtex) { |pub| contribs << pub }
-
-        contribs
-      end
-
-      def fetch_howpublished(bibtex, &_)
-        return unless bibtex["howpublished"]
-
-        /\\publisher\{(?<name>.+)\},\\url\{(?<url>.+)\}/ =~ bibtex.howpublished.to_s
-        return unless name && url
-
-        name.gsub!(/\{\\?([^\\]+)\}/, '\1')
-        org = Organization.new(name: name, url: url)
-        yield entity: org, role: [{ type: "publisher" }]
-      end
-
-      def fetch_org(org, type, desc = nil, &_)
-        return unless org
-
-        role = { type: type }
-        role[:description] = [desc] if desc
-        yield entity: Organization.new(name: org.to_s), role: [role]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Relaton::Bib::Person>]
-      def fetch_person(bibtex, role, &_) # rubocop:disable Metrics/AbcSize
-        bibtex[role]&.each do |name|
-          parts = name.split ", "
-          surname = LocalizedString.new parts.first
-          fname = parts.size > 1 ? parts[1].split : []
-          forename = fname.map { |fn| Forename.new content: fn }
-          name = FullName.new(surname: surname, forename: forename)
-          yield entity: Person.new(name: name), role: [{ type: role }]
-        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 [Relaton::Bib::BiblioNoteCollection]
-      def fetch_note(bibtex) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-        bibtex.select do |k, _v|
-          %i[annote howpublished comment note content].include? k
-        end.reduce(BiblioNoteCollection.new([])) do |mem, note|
-          type = case note[0]
-                 when :note then nil
-                 when :content then "tableOfContents"
-                 else note[0].to_s
-                 end
-          next mem if type == "howpublished" && note[1].to_s.match?(/^\\publisher\{.+\},\\url\{.+\}$/)
-
-          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"]
-
-        ttl = Title.new(type: "main", content: bibtex.booktitle.to_s)
-        title = TitleCollection.new [ttl]
-        [{ type: "partOf", bibitem: Item.new(title: title) }]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<RelatonBib::Extent>]
-      def fetch_extent(bibtex) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        locs = 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 << Locality.new(type, from, to)
-        end
-        [RelatonBib::Extent.new(locs)]
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Relaton::Bib::Series>]
-      def fetch_series(bibtex) # rubocop:disable Metrics/MethodLength
-        series = []
-        if bibtex["journal"]
-          series << Series.new(
-            type: "journal",
-            title: Title.new(content: bibtex.journal.to_s),
-            number: bibtex["number"]&.to_s,
-          )
-        end
-
-        if bibtex["series"]
-          title = Title.new content: bibtex.series.to_s
-          series << Series.new(title: title)
-        end
-        series
-      end
-
-      # @param bibtex [BibTeX::Entry]
-      # @return [Array<Relaton::Bib::Bsource>]
-      def fetch_link(bibtex) # rubocop:disable Metrics/AbcSize
-        link = []
-        link << Bsource.new(type: "src", content: bibtex.url.to_s) if bibtex["url"]
-        link << Bsource.new(type: "doi", content: bibtex.doi.to_s) if bibtex["doi"]
-        link << Bsource.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 [Relaton::Bib::Classification, nil]
-      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(/,\s?/) || []
-      end
-    end
-  end
-end

data/lib/relaton/bibxml_parser.rb

@@ -1,419 +0,0 @@
-module Relaton
-  module BibXMLParser
-    # SeriesInfo what should be saved as docidentifiers in the Relaton model.
-    SERIESINFONAMES = ["DOI"].freeze
-    RFCPREFIXES = %w[RFC BCP FYI STD].freeze
-
-    FLAVOR = nil
-
-    ORGNAMES = {
-      "IEEE" => "Institute of Electrical and Electronics Engineers",
-      "W3C" => "World Wide Web Consortium",
-      "3GPP" => "3rd Generation Partnership Project",
-    }.freeze
-
-    #
-    # Parse BibXML content
-    #
-    # @param [String] bibxml content
-    # @param [String, nil] url source URL
-    # @param [Boolean] is_relation true if the content is relation item
-    # @param [String, nil] ver version
-    #
-    # @return [<Type>] <description>
-    #
-    def parse(bibxml, url: nil, is_relation: false, ver: nil)
-      doc = Nokogiri::XML bibxml
-      fetch_rfc doc.at("/referencegroup", "/reference"), url: url, is_relation: is_relation, ver: ver
-    end
-
-    # @param reference [Nokogiri::XML::Element, nil]
-    # @param is_relation [Boolean] don't add fetched date for relation if true
-    # @param url [String, nil]
-    # @param ver [String, nil] Internet Draft version
-    # @return [Relaton::Bib::Item]
-    def fetch_rfc(reference, is_relation: false, url: nil, ver: nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      return unless reference
-
-      hash = {
-        is_relation: is_relation,
-        docnumber: docnumber(reference),
-        type: "standard",
-        docid: docids(reference, ver),
-        status: status(reference),
-        language: [language(reference)],
-        script: ["Latn"],
-        link: link(reference, url, ver),
-        title: titles(reference),
-        formattedref: formattedref(reference),
-        abstract: abstracts(reference),
-        contributor: contributors(reference),
-        relation: relations(reference),
-        date: dates(reference),
-        editorialgroup: editorialgroup(reference),
-        series: series(reference),
-        keyword: reference.xpath("front/keyword").map(&:text),
-        doctype: doctype(reference[:anchor]),
-      }
-      # hash[:fetched] = Date.today.to_s unless is_relation
-      bib_item(**hash)
-    end
-
-    def docnumber(reference)
-      reference[:anchor]&.sub(/^\w+\./, "")
-    end
-
-    # @param attrs [Hash]
-    # @return [Relaton::Bib::Item]
-    def bib_item(**attrs)
-      # attrs[:place] = ["Fremont, CA"]
-      Item.new(**attrs)
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [String]
-    def language(reference)
-      reference[:lang] || "en"
-    end
-
-    #
-    # Extract document identifiers from reference
-    #
-    # @param reference [Nokogiri::XML::Element]
-    # @param ver [String, nil] Internet Draft version
-    #
-    # @return [Array<Relaton::Bib::Docidentifier>]
-    #
-    def docids(reference, ver) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
-      ret = []
-      si = reference.at("./seriesInfo[@name='Internet-Draft']",
-                        "./front/seriesInfo[@name='Internet-Draft']")
-      if si
-        id = si[:value]
-        id.sub!(/(?<=-)\d{2}$/, ver) if ver
-        ret << Bib::Docidentifier.new(type: "Internet-Draft", id: id, primary: true)
-      else
-        id = reference[:anchor] || reference[:docName] || reference[:number]
-        ret << create_docid(id, ver) if id
-      end
-
-      %w[anchor docName number].each do |atr|
-        if reference[atr]
-          pref, num = id_to_pref_num reference[atr]
-          atrid = if atr == "anchor" && RFCPREFIXES.include?(pref)
-                    "#{pref}#{num.sub(/^-?0+/, '')}"
-                  else
-                    reference[atr]
-                  end
-          type = pubid_type id
-          ret << Bib::Docidentifier.new(id: atrid, type: type, scope: atr)
-        end
-      end
-
-      ret + reference.xpath("./seriesInfo", "./front/seriesInfo").map do |si|
-        next unless SERIESINFONAMES.include? si[:name]
-
-        id = si[:value]
-        # id.sub!(/(?<=-)\d{2}$/, ver) if ver && si[:name] == "Internet-Draft"
-        Bib::Docidentifier.new(id: id, type: si[:name])
-      end.compact
-    end
-
-    def create_docid(id, ver) # rubocop:disable Metrics/MethodLength
-      pref, num = id_to_pref_num(id)
-      if RFCPREFIXES.include?(pref)
-        pid = "#{pref} #{num.sub(/^-?0+/, '')}"
-        type = pubid_type id
-      elsif %w[I-D draft].include?(pref)
-        pid = "draft-#{num}"
-        pid.sub!(/(?<=-)\d{2}$/, ver) if ver
-        type = "Internet-Draft"
-      else
-        pid = pref ? "#{pref} #{num}" : id
-        type = pubid_type id
-      end
-      Docidentifier.new(type: type, id: pid, primary: true)
-    end
-
-    def id_to_pref_num(id)
-      tn = /^(?<pref>I-D|draft|3GPP|W3C|[A-Z]{2,})[._-]?(?<num>.+)/.match id
-      tn && tn.to_a[1..2]
-    end
-
-    #
-    # Extract document identifier type from identifier
-    #
-    # @param [String] id identifier
-    #
-    # @return [String]
-    #
-    def pubid_type(id)
-      id_to_pref_num(id)&.first
-    end
-
-    #
-    # extract status
-    # @param reference [Nokogiri::XML::Element]
-    #
-    # @return [Relaton::Bib::DocumentStatus]
-    #
-    def status(reference)
-      st = reference.at("./seriesinfo[@status]")
-      DocumentStatus.new(stage: st[:status]) if st
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @param url [String]
-    # @param ver [String, nil] Internet Draft version
-    # @return [Array<Hash>]
-    def link(reference, url, ver)
-      l = []
-      l << { type: "xml", content: url } if url
-      l << { type: "src", content: reference[:target] } if reference[:target]
-      if /^I-D/.match? reference[:anchor]
-        reference.xpath("format").each do |f|
-          c = ver ? f[:target].sub(/(?<=-)\d{2}(?=\.)/, ver) : f[:target]
-          l << { type: f[:type], content: c }
-        end
-      end
-      l
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Array<Hash>]
-    def titles(reference)
-      reference.xpath("./front/title").map do |title|
-        { content: title.text, language: language(reference), script: "Latn" }
-      end
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Relaton::Bib::Formattedref, nil]
-    def formattedref(reference)
-      return if reference.at "./front/title"
-
-      cont = reference[:anchor] || reference[:docName] || reference[:number]
-      if cont
-        Formattedref.new(
-          content: cont, language: language(reference), script: "Latn",
-        )
-      end
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Array<Relaton::Bib::FormattedString>]
-    def abstracts(ref)
-      ref.xpath("./front/abstract").map do |a|
-        c = a.inner_html.gsub(/\s*(<\/?)t(>)\s*/, '\1p\2').gsub(/[\t\n]/, " ").squeeze " "
-        Bib::FormattedString.new(content: c, language: language(ref), script: "Latn", format: "text/html")
-      end
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Array<Hash>]
-    def contributors(reference)
-      lang = language reference
-      reference.xpath("./front/author").map do |contrib|
-        entity = person(contrib, lang) || organization(contrib)
-        next unless entity
-
-        { entity: entity, role: [contributor_role(contrib)] }
-      end.compact
-    end
-
-    # @param author [Nokogiri::XML::Element]
-    # @param lang [String]
-    # @return [Relaton::Bib::Person, nil]
-    def person(author, lang)
-      return unless author[:fullname] || author[:surname]
-
-      name = full_name(author[:fullname], author[:surname], author[:initials], lang)
-      Bib::Person.new(name: name, affiliation: affiliation(author), contact: contacts(author.at("./address")))
-    end
-
-    # @param contrib [Nokogiri::XML::Element]
-    # @return [Relaton::Bib::Organization, nil]
-    def organization(contrib)
-      org = contrib.at("./organization")
-      return unless org
-
-      orgname = org.text.strip
-      return if orgname.empty?
-
-      name = ORGNAMES[orgname] || orgname
-      new_org name, org[:abbrev]
-    end
-
-    # @param fname [String] full name
-    # @param sname [String] surname
-    # @param inits [String] initials
-    # @param lang [String] language
-    # @return [Relaton::Bib::FullName]
-    def full_name(fname, sname, inits, lang)
-      initials = localized_string(inits, lang) if inits
-      Bib::FullName.new(
-        completename: localized_string(fname, lang), initials: initials,
-        forename: forename(inits, lang), surname: localized_string(sname, lang)
-      )
-    end
-
-    #
-    # Create forenames with initials
-    #
-    # @param [String] initials initials
-    # @param [String] lang language
-    #
-    # @return [Array<Relaton::Bib::Forename>] forenames
-    #
-    def forename(initials, lang = nil, script = nil)
-      return [] unless initials
-
-      initials.split(/\.-?\s?|\s/).map do |i|
-        Bib::Forename.new(initial: i, language: lang, script: script)
-      end
-    end
-
-    # @param author [Nokogiri::XML::Element]
-    # @return [Array<Relaton::Bib::Affiliation>]
-    def affiliation(author)
-      o = author.at("./organization")
-      return [] if o.nil? || o.text.empty?
-
-      org = new_org o.text, o[:abbrev]
-      [Bib::Affiliation.new(organization: org)]
-    end
-
-    # @param name [String]
-    # @param abbr [String, nil]
-    # @return [Relaton::Bib::Organization]
-    def new_org(name, abbr = nil)
-      Bib::Organization.new name: name, abbreviation: abbr
-    end
-
-    # @param content [String, nil]
-    # @param lang [String, nil]
-    # @param script [String, nil]
-    # @return [Relaton::Bib::LocalizedString, nil]
-    def localized_string(content, lang, script = nil)
-      Bib::LocalizedString.new(content: content, laguage: lang, script: script) if content
-    end
-
-    # @param postal [Nokogiri::XML::Element]
-    # @return [Array<Relaton::Bib::Address, Relaton::Bib::Phone>]
-    def contacts(addr)
-      conts = []
-      return conts unless addr
-
-      postal = addr.at("./postal")
-      conts << address(postal) if postal&.at("./city") && postal&.at("./country")
-      add_contact(conts, "phone", addr.at("./phone"))
-      add_contact(conts, "email", addr.at("./email"))
-      add_contact(conts, "uri", addr.at("./uri"))
-      conts
-    end
-
-    # @param postal [Nokogiri::XML::Element]
-    # @return [Relaton::Bib::Address]
-    def address(postal) # rubocop:disable Metrics/CyclomaticComplexity
-      street = [postal.at("./postalLine | ./street")&.text].compact
-      Bib::Address.new(
-        street: street,
-        city: postal.at("./city")&.text,
-        postcode: postal.at("./code")&.text,
-        country: postal.at("./country")&.text,
-        state: postal.at("./region")&.text,
-      )
-    end
-
-    # @param conts [Array<Relaton::Bib::Address, Relaton::Bib::Contact>]
-    # @param type [String] allowed "phone", "email" or "uri"
-    # @param value [String]
-    def add_contact(conts, type, value)
-      conts << Bib::Contact.new(type: type, value: value.text) if value
-    end
-
-    # @param author [Nokogiri::XML::Document]
-    # @return [Hash]
-    def contributor_role(author)
-      { type: author[:role] || "author" }
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Hash]
-    def relations(reference)
-      reference.xpath("reference").map do |ref|
-        { type: "includes", bibitem: fetch_rfc(ref, is_relation: true) }
-      end
-    end
-
-    #
-    # Extract date from reference.
-    #
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Array<Relaton::Bib::Bdate>] published data.
-    #
-    def dates(reference) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
-      date = reference.at "./front/date"
-      return [] if date.nil? || date[:year].nil? || date[:year].empty?
-
-      d = date[:year]
-      d += "-#{month(date[:month])}" if date[:month] && !date[:month].empty?
-      d += "-#{date[:day]}" if date[:day]
-      # date = Time.parse(d).strftime "%Y-%m-%d"
-      [Bib::Date.new(type: "published", on: d)]
-    end
-
-    # @param reference [Nokogiri::XML::Element]
-    # @return [Relaton::Bib::EditorialGroup, nil]
-    def editorialgroup(reference)
-      tc = reference.xpath("./front/workgroup").map do |ed|
-        wg = Bib::WorkGroup.new name: ed.text
-        committee wg
-      end
-      EditorialGroup.new tc if tc.any?
-    end
-
-    # @param [Relaton::Bib::WorkGroup]
-    # @return [Relaton::Bib::TechnicalCommittee]
-    def committee(wgr)
-      Bib::TechnicalCommittee.new wgr
-    end
-
-    def month(mon)
-      # return 1 if !mon || mon.empty?
-      return mon if /^\d+$/.match? mon
-
-      Date::MONTHNAMES.index { |m| m&.include? mon }.to_s.rjust 2, "0"
-    end
-
-    #
-    # Extract series form reference
-    # @param reference [Nokogiri::XML::Element]
-    #
-    # @return [Array<Relaton::Bib::Series>]
-    #
-    def series(reference)
-      reference.xpath("./seriesInfo", "./front/seriesInfo").map do |si|
-        next if SERIESINFONAMES.include?(si[:name]) || si[:stream] || si[:status]
-
-        t = Title.new(
-          content: si[:name], language: language(reference), script: "Latn",
-        )
-        Series.new(title: t, number: si[:value], type: "main")
-      end.compact
-    end
-
-    # @param anchor [String]
-    # @return [String]
-    def doctype(anchor)
-      type =  case anchor
-              when /I-D/ then "internet-draft"
-              when /IEEE/ then "ieee"
-              else "rfc"
-              end
-      DocumentType.new type: type
-    end
-
-    extend BibXMLParser
-  end
-end

data/lib/relaton/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