relaton-bib 1.9.4 → 1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f54471913accf8362c7e96a1679e62e7f73092d12cb24156797837084371f06
-  data.tar.gz: b9c94af722de0e6fd41064aa1a15a7f604698f525c24bb611ddc3430eea0b4ac
+  metadata.gz: 1d329cd83e84f6c8c77e88d4d621b15fcfc51e392b037283ba349a428bf317dd
+  data.tar.gz: 5f68269fd3ac149966bca54f1e472d2fd7ef976dbaa567873561013414b1d3e2
 SHA512:
-  metadata.gz: 38dccc66a7bf1f7b49b471d1f3dd97e75a925d86dde075a1778b065bcfd6767406e26e5c38a954d17ea824ba06a43ee4eacada09ceeabf91f38615fccd480dc0
-  data.tar.gz: 8339ccfb65c672dd5f1a3928696cc1ca9e0f055b605c4ec631046a668603f756bd1f7e56547863453cddfdde3950538d48c2e6ad6990cbefbdb459bd6ce31d48
+  metadata.gz: 776eed6d08cb7580a04a5949a6bd1bb3c729c9d4331eddd3ad8ec8404da1bc0e5df73e296b673549dba74b3e0aa07048f98f98202f2b5351bbc3db4057f090f0
+  data.tar.gz: ee5864e41161f2990861052e299a03d044ab3305df1a3a940621837c5eae52eafe3ca4e5ea1a8d0b61a3ea2d907b4907b9b16cf4dad213de310061364ec7215a

data/lib/relaton_bib/bibliographic_item.rb

@@ -766,17 +766,48 @@ module RelatonBib
     #
     def render_bibxml(builder)
       target = link.detect { |l| l.type == "src" } || link.detect { |l| l.type == "doi" }
-      bxml = builder.reference(anchor: id) do |xml|
+      bxml = builder.reference(anchor: anchor) do |xml|
         xml.front do
           xml.title title[0].title.content if title.any?
           render_seriesinfo xml
           render_authors xml
           render_date xml
+          render_workgroup xml
+          render_keyword xml
+          render_abstract xml
         end
       end
       bxml[:target] = target.content.to_s if target
     end
 
+    def anchor
+      did = docidentifier.detect { |di| di.type == "rfc-anchor" }
+      return did.id if did
+
+      type = docidentifier[0].type
+      "#{type}.#{docnumber}"
+    end
+
+    def render_keyword(builder)
+      keyword.each do |kw|
+        builder.keyword kw.content
+      end
+    end
+
+    def render_workgroup(builder)
+      editorialgroup&.technical_committee&.each do |tc|
+        builder.workgroup tc.workgroup.name
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    def render_abstract(builder)
+      return unless abstract.any?
+
+      builder.abstract { |xml| xml << abstract[0].content }
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
     def render_date(builder)
       dt = date.detect { |d| d.type == "published" }
       return unless dt
@@ -790,10 +821,10 @@ module RelatonBib
       elm[:day] = d if d
     end
 
+    # @param [Nokogiri::XML::Builder] builder
     def render_seriesinfo(builder)
-      names = ["DOI", "Internet-Draft"]
       docidentifier.each do |di|
-        if names.include? di.type
+        if BibXMLParser::SERIESINFONAMES.include? di.type
           builder.seriesInfo(name: di.type, value: di.id)
         end
       end
@@ -806,6 +837,7 @@ module RelatonBib
       end
     end
 
+    # @param [Nokogiri::XML::Builder] builder
     def render_authors(builder)
       contributor.each do |c|
         builder.author do |xml|
@@ -818,26 +850,40 @@ module RelatonBib
       end
     end
 
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::ContributionInfo] contrib
     def render_address(builder, contrib)
-      addr = contrib.entity.contact.reject do |cn|
-        cn.is_a?(Address) && cn.postcode.nil?
-      end
-      if addr.any?
+      # addr = contrib.entity.contact.reject do |cn|
+      #   cn.is_a?(Address) && cn.postcode.nil?
+      # end
+      if contrib.entity.contact.any?
         builder.address do |xml|
-          address = addr.detect { |cn| cn.is_a? Address }
-          xml.postal address.postcode if address.postcode
-          render_contact xml, addr
+          address = contrib.entity.contact.detect { |cn| cn.is_a? Address }
+          if address
+            xml.postal do
+              xml.city address.city if address.city
+              xml.code address.postcode if address.postcode
+              xml.country address.country if address.country
+              xml.region address.state if address.state
+              xml.street address.street[0] if address.street.any?
+            end
+          end
+          render_contact xml, contrib.entity.contact
         end
       end
     end
 
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [Array<RelatonBib::Address, RelatonBib::Contact>] addr
     def render_contact(builder, addr)
       %w[phone email uri].each do |type|
         cont = addr.detect { |cn| cn.is_a?(Contact) && cn.type == type }
-        builder.phone cont.value if cont
+        builder.send type, cont.value if cont
       end
     end
 
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::Person] person
     def render_person(builder, person)
       render_organization builder, person.affiliation.first&.organization
       if person.name.completename
@@ -851,11 +897,13 @@ module RelatonBib
       end
     end
 
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::Organization] org
     def render_organization(builder, org)
       return unless org
 
       o = builder.organization org.name.first&.content
-      o[:abbrev] = org.abbreviation if org.abbreviation
+      o[:abbrev] = org.abbreviation.content if org.abbreviation
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/relaton_bib/bibxml_parser.rb

@@ -0,0 +1,345 @@
+module RelatonBib
+  module BibXMLParser
+    SERIESINFONAMES = ["DOI", "Internet-Draft"].freeze
+    FLAVOR = nil
+
+    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 [RelatonBib::BibliographicItem]
+    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 [RelatonBib::IetfBibliographicItem]
+    def bib_item(**attrs)
+      # attrs[:place] = ["Fremont, CA"]
+      BibliographicItem.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<RelatonBib::DocumentIdentifier>]
+    #
+    def docids(reference, ver) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
+      ret = []
+      sfid = reference.at("./seriesInfo[@name='#{self::FLAVOR}']", "./front/seriesInfo[@name='#{self::FLAVOR}']")
+      if sfid
+        ret << DocumentIdentifier.new(type: sfid[:name], id: sfid[:value])
+      elsif self::FLAVOR && (id = (reference[:anchor] || reference[:docName] || reference[:number]))
+        ret << DocumentIdentifier.new( type: self::FLAVOR, id: id.sub(/^(RFC)/, "\\1 "))
+      end
+      if (id = reference[:anchor])
+        ret << DocumentIdentifier.new(type: "rfc-anchor", id: id)
+      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"
+        DocumentIdentifier.new(id: id, type: si[:name])
+      end.compact
+    end
+
+    #
+    # extract status
+    # @param reference [Nokogiri::XML::Element]
+    #
+    # @return [RelatonBib::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 [RelatonBib::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<RelatonBib::FormattedString>]
+    def abstracts(ref)
+      ref.xpath("./front/abstract").map do |a|
+        FormattedString.new(
+          content: a.children.to_s,
+          language: language(ref), script: "Latn", format: "text/html"
+        )
+      end
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<Hash>]
+    def contributors(reference)
+      reference.xpath("./front/author").map do |contrib|
+        if contrib[:fullname] || contrib[:surname] then person(contrib, reference)
+        else organization(contrib)
+        end
+      end.compact
+      # persons(reference) + organizations(reference)
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<Hash{Symbol=>RelatonBib::Person,Symbol=>Array<String>}>]
+    def person(author, reference)
+      # reference.xpath("./front/author[@surname]|./front/author[@fullname]")
+      #   .map do |author|
+      entity = Person.new(
+        name: full_name(author, reference),
+        affiliation: affiliation(author),
+        contact: contacts(author.at("./address")),
+      )
+      { entity: entity, role: [contributor_role(author)] }
+      # end
+    end
+
+    # @param contrib [Nokogiri::XML::Element]
+    # @return [Array<Hash{Symbol=>RelatonBib::Organization,
+    #   Symbol=>Array<String>}>]
+    def organization(contrib)
+      # publisher = { entity: new_org, role: [type: "publisher"] }
+      # orgs = reference.xpath("./seriesinfo").reduce([]) do |mem, si|
+      #   next mem unless si[:stream]
+
+      #   mem << { entity: new_org(si[:stream], nil), role: [type: "author"] }
+      # end
+      # orgs + reference.xpath(
+      #   "front/author[not(@surname)][not(@fullname)]/organization",
+      # ).map do |org|
+      org = contrib.at("./organization")
+      { entity: new_org(org.text, org[:abbrev]), role: [contributor_role(contrib)] }
+      # end
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @param reference [Nokogiri::XML::Element]
+    # @return [RelatonBib::FullName]
+    def full_name(author, reference)
+      lang = language reference
+      FullName.new(
+        completename: localized_string(author[:fullname], lang),
+        initial: [localized_string(author[:initials], lang)].compact,
+        surname: localized_string(author[:surname], lang),
+      )
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::Affiliation>]
+    def affiliation(author)
+      o = author.at("./organization")
+      return [] if o.nil? || o.text.empty?
+
+      org = new_org o.text, o[:abbrev]
+      [Affiliation.new(organization: org)]
+    end
+
+    # @param name [String]
+    # @param abbr [String]
+    # @return [RelatonBib::Organization]
+    def new_org(name, abbr)
+      # (name = "Internet Engineering Task Force", abbr = "IETF")
+      Organization.new name: name, abbreviation: abbr
+    end
+
+    # @param content [String, nil]
+    # @param lang [String, nil]
+    # @return [RelatonBib::LocalizedString, nil]
+    def localized_string(content, lang)
+      LocalizedString.new(content, lang) if content
+    end
+
+    # @param postal [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::Address, RelatonBib::Phone>]
+    def contacts(addr)
+      conts = []
+      return conts unless addr
+
+      postal = addr.at("./postal")
+      conts << address(postal) if postal
+      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]
+    # @rerurn [RelatonBib::Address]
+    def address(postal) # rubocop:disable Metrics/CyclomaticComplexity
+      street = [
+        (postal.at("./postalLine") || postal.at("./street"))&.text
+      ].compact
+      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<RelatonBib::Address, RelatonBib::Contact>]
+    # @param type [String] allowed "phone", "email" or "uri"
+    # @param value [String]
+    def add_contact(conts, type, value)
+      conts << 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<RelatonBib::BibliographicDate>] published data.
+    #
+    def dates(reference)
+      return unless (date = reference.at "./front/date")
+
+      d = [date[:year], month(date[:month]), (date[:day] || 1)].compact.join "-"
+      date = Time.parse(d).strftime "%Y-%m-%d"
+      [BibliographicDate.new(type: "published", on: date)]
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [RelatonBib::EditorialGroup, nil]
+    def editorialgroup(reference)
+      tc = reference.xpath("./front/workgroup").map do |ed|
+        wg = WorkGroup.new name: ed.text
+        committee wg
+      end
+      EditorialGroup.new tc if tc.any?
+    end
+
+    # @param [RelatonBib::WorkGroup]
+    # @return [RelatonBib::TechnicalCommittee]
+    def committee(wgr)
+      TechnicalCommittee.new wgr
+    end
+
+    def month(mon)
+      return 1 if !mon || mon.empty?
+      return mon if /^\d+$/.match? mon
+
+      Date::MONTHNAMES.index(mon)
+    end
+
+    #
+    # Extract series form reference
+    # @param reference [Nokogiri::XML::Element]
+    #
+    # @return [Array<RelatonBib::Series>]
+    #
+    def series(reference)
+      reference.xpath("./seriesInfo", "./front/seriesInfo").map do |si|
+        next if si[:name] == "DOI" || si[:stream] || si[:status]
+
+        t = TypedTitleString.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)
+      case anchor
+      when /I-D/ then "internet-draft"
+      when /IEEE/ then "ieee"
+      else "rfc"
+      end
+    end
+
+    extend BibXMLParser
+  end
+end

data/lib/relaton_bib/contributor.rb

@@ -138,7 +138,7 @@ module RelatonBib
         desc = description.select { |d| d.language&.include? opts[:lang] }
         desc = description unless desc.any?
         desc.each { |d| builder.description { d.to_xml builder } }
-        organization.to_xml **opts
+        organization.to_xml(**opts)
       end
     end
 

data/lib/relaton_bib/localized_string.rb

@@ -56,7 +56,7 @@ module RelatonBib
       else
         builder.parent["language"] = language.join(",") if language&.any?
         builder.parent["script"]   = script.join(",") if script&.any?
-        builder.text content.encode(xml: :text)
+        builder.parent << content # .encode(xml: :text)
       end
     end
 

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.9.4".freeze
+  VERSION = "1.9.5".freeze
 end

data/lib/relaton_bib/xml_parser.rb

@@ -320,7 +320,7 @@ module RelatonBib
       # @return [Array<RelatonBib::FormattedString>]
       def fetch_abstract(item)
         item.xpath("./abstract").map do |a|
-          FormattedString.new(content: a.text, language: a[:language],
+          FormattedString.new(content: a.children.to_s, language: a[:language],
                               script: a[:script], format: a[:format])
         end
       end

data/lib/relaton_bib.rb

@@ -6,6 +6,7 @@ require "relaton_bib/localized_string"
 require "relaton_bib/bibliographic_item"
 require "relaton_bib/hit_collection"
 require "relaton_bib/hit"
+require "relaton_bib/bibxml_parser"
 
 module RelatonBib
   class Error < StandardError; end

data/relaton-bib.gemspec

@@ -27,6 +27,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rails"
   spec.add_development_dependency "ruby-jing"
   spec.add_development_dependency "simplecov"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-bib
 version: !ruby/object:Gem::Version
-  version: 1.9.4
+  version: 1.9.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -66,6 +66,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-jing
   requirement: !ruby/object:Gem::Requirement
@@ -182,6 +224,7 @@ files:
 - lib/relaton_bib/bibliographic_date.rb
 - lib/relaton_bib/bibliographic_item.rb
 - lib/relaton_bib/bibtex_parser.rb
+- lib/relaton_bib/bibxml_parser.rb
 - lib/relaton_bib/classification.rb
 - lib/relaton_bib/contribution_info.rb
 - lib/relaton_bib/contributor.rb