relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.1

data/lib/relaton/bib/converter/bibxml/to_rfcxml.rb

@@ -0,0 +1,308 @@
+require "cgi"
+
+module Relaton
+  module Bib
+    module Converter
+      module BibXml
+        class ToRfcxml
+          def initialize(item, include_keywords: true)
+            @item = item
+            @include_keywords = include_keywords
+          end
+
+          def transform
+            model = ::Rfcxml::V3::Reference.new
+            model.anchor = @item.docnumber || derive_anchor
+            model.target = create_target
+            model.front = create_front
+            model.format = create_format
+            model
+          end
+
+          private
+
+          def derive_anchor
+            di = @item.docidentifier.detect(&:primary) || @item.docidentifier[0]
+            di&.content&.to_s&.gsub(" ", ".")
+          end
+
+          def create_target
+            target = @item.source.detect { |l| l.type.casecmp("src").zero? } ||
+              @item.source.detect { |l| l.type.casecmp("doi").zero? }
+            return unless target
+
+            target.content.to_s
+          end
+
+          def create_front # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            front = ::Rfcxml::V3::Front.new
+            front.title = Rfcxml::V3::Title.new(content: @item.title[0].content) if @item.title.any?
+            front.series_info = create_seriesinfo
+            front.author = create_authors
+            front.date = create_date
+            front.workgroup = create_workgroup
+            front.keyword = create_keyword if @include_keywords
+            front.abstract = create_abstract
+            front
+          end
+
+          def create_seriesinfo
+            docidentifier_to_seriesinfo + series_to_seriesinfo
+          end
+
+          def docidentifier_to_seriesinfo
+            @item.docidentifier.each_with_object([]) do |di, si|
+              if di.type == "DOI" && di.scope != "trademark"
+                si << Rfcxml::V3::SeriesInfo.new(name: di.type,
+                                                 value: di.content)
+              end
+            end
+          end
+
+          def series_to_seriesinfo # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+            @item.series.select do |s|
+              s.title.reject { |t| t.content == "DOI" }.any?
+            end.uniq do |s|
+              s.title.find { |t| t.content != "DOI" }.content
+            end.each_with_object([]) do |s, si|
+              title = s.title.find { |t| t.content != "DOI" }
+              si << Rfcxml::V3::SeriesInfo.new(name: title.content,
+                                               value: s.number)
+            end
+          end
+
+          def create_authors # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            @item.contributor.reject { |c| committee_contributor?(c) }.map do |contrib|
+              role = "editor" if contrib.role.detect { |r| r.type == "editor" }
+              Rfcxml::V3::Author.new(
+                role: role,
+                initials: person_initials(contrib.person),
+                surname: person_surname(contrib.person),
+                fullname: person_fullname(contrib.person),
+                organization: create_organization(contrib),
+                address: create_address(contrib),
+              )
+            end
+          end
+
+          def person_fullname(person) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+            return unless person
+
+            if person.name.completename
+              person.name.completename.content
+            elsif person.name.forename.any?
+              parts = person.name.forename.map { |n| n.content || n.initial }
+              parts << person.name.surname.content if person.name.surname
+              parts.join(" ")
+            end
+          end
+
+          def person_initials(person) # rubocop:disable Metrics/AbcSize
+            return unless person
+
+            if person.name.formatted_initials
+              person.name.formatted_initials.content
+            elsif person.name.forename.any?
+              person.name.forename.map do |f|
+                "#{f.initial || f.content[0]}."
+              end.join " "
+            end
+          end
+
+          def person_surname(person)
+            return unless person
+
+            person.name.surname&.content
+          end
+
+          def create_organization(contrib) # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+            org = contrib_org(contrib)
+            return unless org
+
+            abbrev = org.abbreviation&.content
+            orgname = resolve_orgname(org, abbrev)
+            Rfcxml::V3::Organization.new(
+              content: [orgname], abbrev: abbrev,
+            )
+          end
+
+          def contrib_org(contrib)
+            contrib.organization ||
+              (contrib.person && contrib.person.affiliation[0]&.organization)
+          end
+
+          def resolve_orgname(org, abbrev)
+            orgname = org.name&.first&.content
+            if ORGNAMES.key?(abbrev) then abbrev
+            else ORGNAMES.key(orgname) || orgname || abbrev
+            end
+          end
+
+          def create_address(contrib) # rubocop:disable Metrics/AbcSize
+            entity = contrib.person || contrib.organization
+            return unless entity.address.any? || entity.phone.any? ||
+              entity.email.any? || entity.uri.any?
+
+            Rfcxml::V3::Address.new(
+              postal: address_postal(entity),
+              phone: address_phone(entity),
+              email: address_email(entity),
+              uri: address_uri(entity),
+            )
+          end
+
+          def address_postal(entity)
+            args = address_postal_args(entity)
+            return unless args.values.any?(&:any?)
+
+            Rfcxml::V3::Postal.new(**args)
+          end
+
+          def address_postal_args(entity)
+            {
+              city: address_cities(entity),
+              code: address_postcodes(entity),
+              country: address_countries(entity),
+              region: address_states(entity),
+              street: address_streets(entity),
+              postal_line: address_postal_lines(entity),
+            }
+          end
+
+          def address_cities(entity)
+            entity.address.each_with_object([]) do |addr, cities|
+              next unless addr.city
+
+              cities << Rfcxml::V3::City.new(content: addr.city)
+            end
+          end
+
+          def address_postcodes(entity)
+            entity.address.each_with_object([]) do |addr, codes|
+              next unless addr.postcode
+
+              codes << Rfcxml::V3::Code.new(content: addr.postcode)
+            end
+          end
+
+          def address_countries(entity)
+            entity.address.each_with_object([]) do |addr, countries|
+              next unless addr.country
+
+              countries << Rfcxml::V3::Country.new(content: addr.country)
+            end
+          end
+
+          def address_states(entity)
+            entity.address.each_with_object([]) do |addr, states|
+              next unless addr.state
+
+              states << Rfcxml::V3::Region.new(content: addr.state)
+            end
+          end
+
+          def address_streets(entity)
+            entity.address.each_with_object([]) do |address, streets|
+              address.street.each do |street|
+                streets << Rfcxml::V3::Street.new(content: street)
+              end
+            end
+          end
+
+          def address_postal_lines(entity)
+            entity.address.each_with_object([]) do |addr, plines|
+              next unless addr.formatted_address
+
+              plines << Rfcxml::V3::PostalLine.new(
+                content: addr.formatted_address,
+              )
+            end
+          end
+
+          def address_phone(entity)
+            return unless entity.phone.any?
+
+            Rfcxml::V3::Phone.new(content: entity.phone[0].content)
+          end
+
+          def address_email(entity)
+            entity.email.each_with_object([]) do |email, emails|
+              emails << Rfcxml::V3::Email.new(content: email)
+            end
+          end
+
+          def address_uri(entity)
+            return unless entity.uri.any?
+
+            Rfcxml::V3::Uri.new(content: entity.uri[0].content)
+          end
+
+          def create_date # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+            pub_date = @item.date.detect { |d| d.type == "published" }
+            return unless pub_date
+
+            args = {}
+            [pub_date.at, pub_date.from, pub_date.to].compact.each do |d|
+              year, month, day = d.split("-")
+              args[:year] ||= year
+              args[:month] ||= ::Date::MONTHNAMES[month.to_i]
+              args[:day] ||= day
+            end
+            Rfcxml::V3::Date.new(**args)
+          end
+
+          def committee_contributor?(contrib)
+            contrib.role.any? do |r|
+              r.type == "author" &&
+                r.description.any? { |d| d.content == "committee" }
+            end
+          end
+
+          def create_workgroup
+            @item.contributor.each_with_object([]) do |contrib, wgs|
+              next unless committee_contributor?(contrib)
+
+              contrib.organization&.subdivision&.each do |sd|
+                sd.name.each do |n|
+                  wgs << Rfcxml::V3::Workgroup.new(content: n.content)
+                end
+              end
+            end
+          end
+
+          def create_keyword
+            @item.keyword.inject([]) do |a, k|
+              if k.vocab
+                a + [Rfcxml::V3::Keyword.new(content: k.vocab.content)]
+              else
+                a + k.taxon.map { |t| Rfcxml::V3::Keyword.new(content: t.content) }
+              end
+            end
+          end
+
+          def create_abstract
+            return unless @item.abstract.any?
+
+            content = @item.abstract[0].content
+            paragraphs = content.scan(%r{<p>(.*?)</p>}m).flatten
+            paragraphs = [content] if paragraphs.empty?
+            ts = paragraphs.map { |p| Rfcxml::V3::Text.new(content: CGI.unescapeHTML(p)) }
+            Rfcxml::V3::Abstract.new(t: ts)
+          end
+
+          FORMAT_TYPES = %w[TXT HTML PDF XML DOC].freeze
+
+          def create_format # rubocop:disable Metrics/AbcSize
+            @item.source.each_with_object([]) do |l, a|
+              next unless FORMAT_TYPES.any? { |ft| l.type.casecmp(ft).zero? }
+
+              a << Rfcxml::V3::Format.new(
+                type: l.type, target: l.content,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/converter/bibxml/to_rfcxml_referencegroup.rb

@@ -0,0 +1,52 @@
+module Relaton
+  module Bib
+    module Converter
+      module BibXml
+        class ToRfcxmlReferencegroup
+          def initialize(item, include_keywords: true)
+            @item = item
+            @include_keywords = include_keywords
+          end
+
+          def transform
+            Rfcxml::V3::Referencegroup.new(
+              anchor: create_anchor,
+              target: create_target,
+              reference: build_references,
+            )
+          end
+
+          private
+
+          def build_references
+            @item.relation&.each_with_object([]) do |rel, refs|
+              next unless rel.type == "includes"
+
+              converter = ToRfcxml.new(
+                rel.bibitem, include_keywords: @include_keywords
+              )
+              refs << converter.transform
+            end
+          end
+
+          def create_anchor
+            docid = @item.docidentifier.detect(&:primary) ||
+              @item.docidentifier[0]
+            return unless docid
+
+            id = docid.content.to_s
+            id.sub(/^(RFC|BCP|FYI|STD) /, '\1').sub(/^\w+\./, "")
+          end
+
+          def create_target
+            target = @item.source.detect { |l| l.type.casecmp("src").zero? } ||
+              @item.source.detect { |l| l.type.casecmp("doi").zero? }
+            return unless target
+
+            target.content.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/converter/bibxml.rb

@@ -0,0 +1,51 @@
+require_relative "bibxml/to_rfcxml"
+require_relative "bibxml/to_rfcxml_referencegroup"
+require_relative "bibxml/from_rfcxml"
+require_relative "bibxml/from_rfcxml_referencegroup"
+
+module Relaton
+  module Bib
+    module Converter
+      module BibXml
+        ORGNAMES = {
+          "IEEE" => "Institute of Electrical and Electronics Engineers",
+          "W3C" => "World Wide Web Consortium",
+          "3GPP" => "3rd Generation Partnership Project",
+        }.freeze
+
+        RFCPREFIXES = %w[RFC BCP FYI STD].freeze
+
+        # Forward: ItemData -> Rfcxml model
+        def self.from_item(item, include_keywords: true) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          if bcp?(item)
+            ToRfcxmlReferencegroup.new(
+              item, include_keywords: include_keywords
+            ).transform
+          else
+            ToRfcxml.new(
+              item, include_keywords: include_keywords
+            ).transform
+          end
+        end
+
+        def self.bcp?(item) # rubocop:disable Metrics/CyclomaticComplexity
+          item.docnumber&.match(/^BCP/) ||
+            (item.docidentifier.detect(&:primary) ||
+              item.docidentifier[0])&.content&.to_s&.include?("BCP")
+        end
+        private_class_method :bcp?
+
+        # Reverse: XML string -> ItemData
+        def self.to_item(xml)
+          if xml.include?("<referencegroup") || xml.include?("<Referencegroup")
+            referencegroup = Rfcxml::V3::Referencegroup.from_xml(xml)
+            FromRfcxmlReferencegroup.new(referencegroup).transform
+          else
+            reference = Rfcxml::V3::Reference.from_xml(xml)
+            FromRfcxml.new(reference).transform
+          end
+        end
+      end
+    end
+  end
+end