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

data/lib/relaton/bib/renderer/bibtex_builder.rb

@@ -0,0 +1,348 @@
+# Monkey patch to fix the issue with month quotes in BibTeX
+module BibTeX
+  class Value
+    def to_s(options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      if options.key?(:filter)
+        opts = options.reject { |k,| k == :filter || (k == :quotes && (!atomic? || symbol?)) }
+        return convert(options[:filter]).to_s(opts)
+      end
+
+      return value.to_s unless options.key?(:quotes) && atomic?
+
+      q = Array(options[:quotes])
+      [q[0], value, q[-1]].compact.join
+    end
+  end
+end
+
+module Relaton
+  module Bib
+    module Renderer
+      # BibTeX builder.
+      class BibtexBuilder
+        ATTRS = %i[
+          type id title author editor booktitle series number edition contributor
+          date address note relation extent classification keyword docidentifier
+          timestamp link
+        ].freeze
+
+        #
+        # Build BibTeX bibliography.
+        #
+        # @param bib [Relaton::Bib::Item]
+        # @param bibtex [BibTeX::Bibliography, nil] BibTeX bibliography
+        #
+        # @return [BibTeX::Bibliography] BibTeX bibliography
+        #
+        def self.build(bib, bibtex = nil)
+          new(bib).build bibtex
+        end
+
+        #
+        # Initialize BibTeX builder.
+        #
+        # @param bib [Relaton::Bib::Item]
+        def initialize(bib)
+          @bib = bib
+        end
+
+        #
+        # Build BibTeX bibliography.
+        #
+        # @param bibtex [BibTeX::Bibliography, nil] BibTeX bibliography
+        #
+        # @return [BibTeX::Bibliography] BibTeX bibliography
+        #
+        def build(bibtex = nil)
+          @item = BibTeX::Entry.new
+          ATTRS.each { |a| send("add_#{a}") }
+          bibtex ||= BibTeX::Bibliography.new
+          bibtex << @item
+          bibtex
+        end
+
+        private
+
+        #
+        # Add type to BibTeX item
+        #
+        def add_type
+          @item.type = bibtex_type
+        end
+
+        # @return [String] BibTeX type
+        def bibtex_type
+          case @bib.type
+          when "standard", nil then "misc"
+          else @bib.type
+          end
+        end
+
+        #
+        # Add ID to BibTeX item
+        #
+        def add_id
+          @item.key = @bib.id
+        end
+
+        #
+        # Add title to BibTeX item
+        #
+        def add_title
+          return unless @bib.title&.any?
+
+          title = @bib.title.find { |t| t.type == "main" } || @bib.title.first
+          return unless title
+
+          @item .title = title.content
+        end
+
+        #
+        # Add booktitle to BibTeX item
+        #
+        def add_booktitle # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+          return unless @bib.relation&.any?
+
+          included_in = @bib.relation.detect { |r| r.type == "includedIn" }
+          return unless included_in && included_in.bibitem.title&.any?
+
+          @item.booktitle = included_in.bibitem.title.first.content
+        end
+
+        #
+        # Add author to BibTeX item
+        #
+        def add_author
+          add_author_editor "author"
+        end
+
+        #
+        # Add editor to BibTeX item
+        #
+        def add_editor
+          add_author_editor "editor"
+        end
+
+        #
+        # Add author or editor to BibTeX item
+        #
+        # @param [String] type "author" or "editor"
+        #
+        def add_author_editor(type) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          retur unless @bib.contributor&.any?
+
+          contribs = @bib.contributor.select do |c|
+            c.person && c.role.any? { |e| e.type == type }
+          end.map &:person
+
+          return unless contribs.any?
+
+          @item.send "#{type}=", concat_names(contribs)
+        end
+
+        #
+        # Concatenate names of contributors
+        #
+        # @param [Array<Relaton::Bib::Person>] contribs contributors
+        #
+        # @return [String] concatenated names
+        #
+        def concat_names(contribs)
+          contribs.map do |p|
+            if p.name.surname
+              "#{p.name.surname.content}, #{p.name.forename.map(&:content).join(' ')}"
+            else
+              p.name.completename.content
+            end
+          end.join(" and ")
+        end
+
+        #
+        # Add series to BibTeX item
+        #
+        def add_series # rubocop:disable Metrics/AbcSize
+          return unless @bib.series
+
+          @bib.series.each do |s|
+            case s.type
+            when "journal"
+              @item.journal = s.title.first.content
+              @item.number = s.number if s.number
+            when nil then @item.series = s.title.first.content
+            end
+          end
+        end
+
+        #
+        # Add number to BibTeX item
+        #
+        def add_number
+          return unless %w[techreport manual].include? @bib.type
+
+          did = @bib.docidentifier.detect { |i| i.primary == true }
+          did ||= @bib.docidentifier.first
+          @item.number = did.content if did
+        end
+
+        #
+        # Add edition to BibTeX item
+        #
+        def add_edition
+          @item.edition = @bib.edition.content if @bib.edition
+        end
+
+        #
+        # Add contributor to BibTeX item
+        #
+        def add_contributor # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+          @bib.contributor.each do |c|
+            rls = c.role.map(&:type)
+            if rls.include?("publisher") then @item.publisher = c.organization.name.first.content
+            elsif rls.include?("distributor")
+              case @bib.type
+              when "techreport" then @item.institution = c.organization.name.first.content
+              when "inproceedings", "conference", "manual", "proceedings"
+                @item.organization = c.organization.name.first.content
+              when "mastersthesis", "phdthesis" then @item.school = c.organization.name.first.content
+              end
+            end
+          end
+        end
+
+        #
+        # Add date to BibTeX item
+        #
+        def add_date
+          Relaton.array(@bib.date).each do |d|
+            case d.type
+            when "published"
+              year, month, = d.at.split("-")
+              @item.year = year
+              @item.month = month if month
+            when "accessed" then @item.urldate = d.at
+            end
+          end
+        end
+
+        #
+        # Add address to BibTeX item
+        #
+        def add_address # rubocop:disable Metrics/AbcSize
+          return unless @bib.place&.any?
+
+          reg = @bib.place[0].region[0].content if @bib.place[0].region.any?
+          addr = [@bib.place[0].formatted_place, @bib.place[0].city, reg]
+          @item.address = addr.compact.join(", ")
+        end
+
+        #
+        # Add note to BibTeX item
+        #
+        def add_note # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+          Relaton.array(@bib.note).each do |n|
+            case n.type
+            when "annote" then @item.annote = n.content
+            when "howpublished" then @item.howpublished = n.content
+            when "comment" then @item.comment = n.content
+            when "tableOfContents" then @item.content = n.content
+            when nil then @item.note = n.content
+            end
+          end
+        end
+
+        #
+        # Add relation to BibTeX item
+        #
+        def add_relation # rubocop:disable Metrics/AbcSize
+          rel = Relaton.array(@bib.relation).detect { |r| r.type == "partOf" }
+          if rel && rel.bibitem.title&.any?
+            title_main = rel.bibitem.title.detect { |t| t.type == "main" }
+            @item.booktitle = title_main.content
+          end
+        end
+
+        #
+        # Add extent to BibTeX item
+        #
+        def add_extent # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          @bib.extent&.each do |extent|
+            extent.locality&.each { |loc| add_locality loc } ||
+              extent.locality_stack&.each { |locs| add_locality_stack locs }
+          end
+        end
+
+        def add_locality_stack(locs)
+          return unless locs
+
+          locs.locality.each { |loc| add_locality loc }
+        end
+
+        def add_locality(loc)
+          case loc.type
+          when "chapter" then @item.chapter = loc.reference_from
+          when "page"
+            value = [loc.reference_from]
+            value << loc.reference_to if loc.reference_to
+            @item.pages = value.join("--")
+          when "volume" then @item.volume = loc.reference_from
+          when "issue" then @item.issue = loc.reference_from
+          end
+        end
+
+        #
+        # Add classification to BibTeX item
+        #
+        def add_classification
+          @bib.classification&.each do |c|
+            case c.type
+            when "type" then @item["type"] = c.content
+            when "mendeley" then @item["mendeley-tags"] = c.content
+            end
+          end
+        end
+
+        #
+        # Add keywords to BibTeX item
+        #
+        def add_keyword
+          if @bib.keyword&.any?
+            @item.keywords = @bib.keyword.reduce([]) { |m, kw| m + kw.taxon.map(&:content) }.join(", ")
+          end
+        end
+
+        #
+        # Add docidentifier to BibTeX item
+        #
+        def add_docidentifier
+          @bib.docidentifier&.each do |i|
+            case i.type
+            when "isbn" then @item.isbn = i.content
+            when "lccn" then @item.lccn = i.content
+            when "issn" then @item.issn = i.content
+            end
+          end
+        end
+
+        #
+        # Add identifier to BibTeX item
+        #
+        def add_timestamp
+          @item.timestamp = @bib.fetched.to_s if @bib.fetched
+        end
+
+        #
+        # Add link to BibTeX item
+        #
+        def add_link # rubocop:disable Metrics/CyclomaticComplexity
+          @bib.source&.each do |l|
+            case l.type&.downcase
+            when "doi" then @item.doi = l.content
+            when "file" then @item.file2 = l.content
+            when "src" then @item.url = l.content
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/renderer/rfc.rb

@@ -0,0 +1,297 @@
+module Relaton
+  module Bib
+    module Renderer
+      module Rfc
+        def self.transform(item, include_keywords: true) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          if item.docnumber&.match(/^BCP/) ||
+              (item.docidentifier.detect(&:primary) || item.docidentifier[0])&.content&.include?("BCP")
+            Refrencegroup.new(item, include_keywords: include_keywords).transform
+          else
+            Reference.new(item, include_keywords: include_keywords).transform
+          end
+        end
+
+        module Shared
+          def initialize(item, include_keywords: true)
+            @item = item
+            @include_keywords = include_keywords
+          end
+
+          def create_anchor
+            docid = @item.docidentifier.detect(&:primary) || @item.docidentifier[0]
+            return unless docid
+
+            docid.content.to_s.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
+
+        class Refrencegroup
+          include Shared
+
+          def transform
+            reference = @item.relation&.each_with_object([]) do |rel, refs|
+              next unless rel.type == "includes"
+
+              refs << Reference.new(rel.bibitem, include_keywords: @include_keywords).transform
+            end
+            Rfcxml::V3::Referencegroup.new(
+              anchor: create_anchor,
+              target: create_target,
+              reference: reference,
+            )
+          end
+        end
+
+        class Reference
+          include Shared
+
+          ORGNAMES = {
+            "IEEE" => "Institute of Electrical and Electronics Engineers",
+            "W3C" => "World Wide Web Consortium",
+            "3GPP" => "3rd Generation Partnership Project",
+          }.freeze
+
+          def transform
+            model = ::Rfcxml::V3::Reference.new
+            model.anchor = create_anchor
+            model.target = create_target
+            model.front = create_front
+            model.format = create_format
+            model
+          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)
+            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_seresinfo + series_to_seriesinfo
+          end
+
+          def docidentifier_to_seresinfo
+            @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.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 do |n|
+                n.content || n.initial
+              end
+              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 { |f| "#{f.initial || f.content[0]}." }.join " "
+            end
+          end
+
+          def person_surname(person)
+            return unless person
+
+            person.name.surname&.content
+          end
+
+          def create_organization(contrib, _role = []) # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+            org = contrib.organization || contrib.person && contrib.person.affiliation[0]&.organization
+            return unless org
+
+            abbrev = org.abbreviation&.content
+            orgname = org.name&.first&.content
+            orgname = if ORGNAMES.key?(abbrev) then abbrev
+                      else ORGNAMES.key(orgname) || orgname || abbrev
+                      end
+            Rfcxml::V3::Organization.new(content: orgname, abbrev: abbrev)
+          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 |address, cities|
+              cities << Rfcxml::V3::City.new(content: address.city) if address.city
+            end
+          end
+
+          def address_postcodes(entity)
+            entity.address.each_with_object([]) do |address, codes|
+              codes << Rfcxml::V3::Code.new(content: address.postcode) if address.postcode
+            end
+          end
+
+          def address_countries(entity)
+            entity.address.each_with_object([]) do |address, countries|
+              countries << Rfcxml::V3::Country.new(content: address.country) if address.country
+            end
+          end
+
+          def address_states(entity)
+            entity.address.each_with_object([]) do |address, states|
+              states << Rfcxml::V3::Region.new(content: address.state) if address.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 |address, plines|
+              plines << Rfcxml::V3::PostalLine.new(content: address.formatted_address) if address.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 create_workgroup
+            @item.ext&.editorialgroup&.technical_committee&.each do |tc|
+              Rfcxml::V3::Workgroup.new content: tc.content
+            end
+          end
+
+          def create_keyword
+            @item.keyword.inject([]) do |a, k|
+              a + k.taxon.map { |t| Rfcxml::V3::Keyword.new content: t.content }
+            end
+          end
+
+          def create_abstract
+            return unless @item.abstract.any?
+
+            Rfcxml::V3::Abstract.new t: [create_text]
+          end
+
+          def create_text
+            Rfcxml::V3::Text.new content: @item.abstract[0].content
+          end
+
+          def create_format
+            @item.source.reduce([]) do |a, l|
+              next a unless l.type.casecmp("TXT").zero? || l.type.casecmp("HTML").zero? ||
+                l.type.casecmp("PDF").zero? || l.type.casecmp("XML").zero? ||
+                l.type.casecmp("DOC").zero?
+
+              a << Rfcxml::V3::Format.new(type: l.type, target: l.content)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/util.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    module Util
+      extend self
+
+      PROGNAME = "relaton-bib".freeze
+
+      def method_missing(method_name, msg = nil, prog = nil, **opts, &block)
+        prog ||= self::PROGNAME
+        Relaton.logger_pool.send method_name, msg, prog, **opts, &block
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        Relaton.logger_pool.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/relaton/bib/version.rb

@@ -0,0 +1,5 @@
+module Relaton
+  module Bib
+    VERSION = "2.0.0-alpha.1".freeze
+  end
+end