relaton-bib 1.4.0 → 2.1.7

data/lib/relaton/bib/converter/bibtex/from_bibtex.rb

@@ -0,0 +1,245 @@
+module Relaton
+  module Bib
+    module Converter
+      module Bibtex
+        class FromBibtex
+          # @param entry [BibTeX::Entry]
+          def initialize(entry)
+            @entry = entry
+          end
+
+          # @return [Relaton::Bib::ItemData]
+          def transform # rubocop:disable Metrics/MethodLength
+            ItemData.new(
+              id: @entry.key,
+              docidentifier: fetch_docid,
+              fetched: fetch_fetched,
+              type: fetch_type,
+              title: fetch_title,
+              contributor: fetch_contributor,
+              date: fetch_date,
+              place: fetch_place,
+              note: fetch_note,
+              relation: fetch_relation,
+              extent: fetch_extent,
+              edition: fetch_edition,
+              series: fetch_series,
+              source: fetch_link,
+              language: fetch_language,
+              classification: fetch_classification,
+              keyword: fetch_keyword,
+            )
+          end
+
+          private
+
+          # @return [Array<Relaton::Bib::Docidentifier>]
+          def fetch_docid # rubocop:disable Metrics/AbcSize
+            docid = [Docidentifier.new(content: @entry.key.to_s, primary: true)]
+            docid << Docidentifier.new(content: @entry.isbn.to_s, type: "isbn") if @entry["isbn"]
+            docid << Docidentifier.new(content: @entry.lccn.to_s, type: "lccn") if @entry["lccn"]
+            docid << Docidentifier.new(content: @entry.issn.to_s, type: "issn") if @entry["issn"]
+            docid
+          end
+
+          # @return [String, nil]
+          def fetch_fetched
+            ::Date.parse(@entry.timestamp.to_s) if @entry["timestamp"]
+          end
+
+          # @return [String]
+          def fetch_type
+            case @entry.type
+            when :mastersthesis, :phdthesis then "thesis"
+            when :conference then "inproceedings"
+            when :misc then "standard"
+            else @entry.type.to_s
+            end
+          end
+
+          # @return [Array<Relaton::Bib::Place>]
+          def fetch_place
+            @entry["address"] ? [Place.new(formatted_place: @entry.address.to_s)] : []
+          end
+
+          # @return [Array<Relaton::Bib::Title>]
+          def fetch_title
+            title = []
+            title << Title.new(type: "main", content: @entry.convert(:latex).title.to_s) if @entry["title"]
+            title << Title.new(type: "main", content: @entry.convert(:latex).subtitle.to_s) if @entry["subtitle"]
+            title
+          end
+
+          # @return [Array<Relaton::Bib::Contributor>]
+          def fetch_contributor # rubocop:disable Metrics/AbcSize
+            contribs = []
+            fetch_person("author") { |c| contribs << c }
+            fetch_person("editor") { |c| contribs << c }
+
+            fetch_org(@entry["publisher"], "publisher") { |c| contribs << c }
+            fetch_org(@entry["institution"], "distributor", "sponsor") { |c| contribs << c }
+            fetch_org(@entry["organization"], "distributor", "sponsor") { |c| contribs << c }
+            fetch_org(@entry["school"], "distributor", "sponsor") { |c| contribs << c }
+
+            fetch_howpublished { |c| contribs << c }
+
+            contribs
+          end
+
+          def fetch_howpublished(&_)
+            return unless @entry["howpublished"]
+
+            /\\publisher\{(?<name>.+)\},\\url\{(?<url>.+)\}/ =~ @entry.howpublished.to_s
+            return unless name && url
+
+            name.gsub!(/\{\\?([^\\]+)\}/, '\1')
+            org = Organization.new(name: [TypedLocalizedString.new(content: name)], url: url)
+            yield Contributor.new(
+              organization: org,
+              role: [Contributor::Role.new(type: "publisher")],
+            )
+          end
+
+          # @param org [String, nil] organization name
+          # @param type [String] role type
+          # @param desc [String, nil] role description
+          def fetch_org(org, type, desc = nil, &_)
+            return unless org
+
+            role_obj = Contributor::Role.new(type: type)
+            role_obj.description = [LocalizedMarkedUpString.new(content: desc)] if desc
+            yield Contributor.new(organization: Organization.new(name: [TypedLocalizedString.new(content: org.to_s)]), role: [role_obj])
+          end
+
+          # @param role [String] contributor role
+          def fetch_person(role, &_) # rubocop:disable Metrics/AbcSize
+            @entry[role]&.each do |name|
+              parts = name.split ", "
+              surname = LocalizedString.new(content: parts.first)
+              fname = parts.size > 1 ? parts[1].split : []
+              forename = fname.map { |fn| FullNameType::Forename.new(content: fn) }
+              name = FullName.new(surname: surname, forename: forename)
+              yield Contributor.new(
+                person: Person.new(name: name),
+                role: [Contributor::Role.new(type: role)],
+              )
+            end
+          end
+
+          # @return [Array<Relaton::Bib::Date>]
+          def fetch_date
+            date = []
+            if @entry["year"]
+              on = ::Date.new(@entry.year.to_i, @entry["month_numeric"]&.to_i || 1).to_s
+              date << Bib::Date.new(type: "published", at: on)
+            end
+
+            if @entry["urldate"]
+              date << Bib::Date.new(type: "accessed", at: ::Date.parse(@entry.urldate.to_s).to_s)
+            end
+
+            date
+          end
+
+          # @return [Array<Relaton::Bib::Note>]
+          def fetch_note # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+            @entry.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
+              next mem if type == "howpublished" && note[1].to_s.match?(/^\\publisher\{.+\},\\url\{.+\}$/)
+
+              mem << Note.new(type: type, content: note[1].to_s)
+            end
+          end
+
+          # @return [Array<Relaton::Bib::Relation>]
+          def fetch_relation
+            return [] unless @entry["booktitle"]
+
+            ttl = Title.new(type: "main", content: @entry.booktitle.to_s)
+            [Relation.new(type: "partOf", bibitem: ItemData.new(title: [ttl]))]
+          end
+
+          # @return [Array<Relaton::Bib::Extent>]
+          def fetch_extent # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+            locs = @entry.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: type, reference_from: from, reference_to: to)
+            end
+            [Extent.new(locality: locs)]
+          end
+
+          # @return [Array<Relaton::Bib::Series>]
+          def fetch_series # rubocop:disable Metrics/MethodLength
+            series = []
+            if @entry["journal"]
+              series << Series.new(
+                type: "journal",
+                title: Title.new(content: @entry.journal.to_s),
+                number: @entry["number"]&.to_s,
+              )
+            end
+
+            if @entry["series"]
+              title = Title.new content: @entry.series.to_s
+              series << Series.new(title: title)
+            end
+            series
+          end
+
+          # @return [Array<Relaton::Bib::Uri>]
+          def fetch_link # rubocop:disable Metrics/AbcSize
+            link = []
+            link << Uri.new(type: "src", content: @entry.url.to_s) if @entry["url"]
+            link << Uri.new(type: "doi", content: @entry.doi.to_s) if @entry["doi"]
+            link << Uri.new(type: "file", content: @entry.file2.to_s) if @entry["file2"]
+            link
+          end
+
+          # @return [Array<String>]
+          def fetch_language
+            return [] unless @entry["language"]
+
+            [Iso639[@entry.language.to_s].alpha2]
+          end
+
+          # @return [Array<Relaton::Bib::Docidentifier>]
+          def fetch_classification
+            cls = []
+            cls << Docidentifier.new(type: "type", content: @entry["type"].to_s) if @entry["type"]
+            if @entry["mendeley-tags"]
+              cls << Docidentifier.new(type: "mendeley", content: @entry["mendeley-tags"].to_s)
+            end
+            cls
+          end
+
+          # @return [Array<Relaton::Bib::Keyword>]
+          def fetch_keyword
+            @entry["keywords"]&.split(/,\s?/)&.map do |kw|
+              Keyword.new(vocab: LocalizedString.new(content: kw))
+            end || []
+          end
+
+          # @return [Relaton::Bib::Edition, nil]
+          def fetch_edition
+            Edition.new(content: @entry["edition"].to_s) if @entry["edition"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/converter/bibtex/to_bibtex.rb

@@ -0,0 +1,341 @@
+# 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 # rubocop:disable Style/OneClassPerFile
+  module Bib
+    module Converter
+      module Bibtex
+        class ToBibtex
+          include Core::ArrayWrapper
+
+          ATTRS = %i[
+            type id title author editor booktitle series number edition contributor
+            date address note relation extent classification keyword docidentifier
+            timestamp link
+          ].freeze
+
+          #
+          # Initialize ToBibtex.
+          #
+          # @param bib [Relaton::Bib::ItemData]
+          def initialize(bib)
+            @bib = bib
+          end
+
+          #
+          # Build BibTeX bibliography.
+          #
+          # @param bibtex [BibTeX::Bibliography, nil] BibTeX bibliography
+          #
+          # @return [BibTeX::Bibliography] BibTeX bibliography
+          #
+          def transform(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
+            return 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
+            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.to_s
+              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
+            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 = 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([]) do |m, kw|
+                  m + (kw.vocab ? [kw.vocab.content] : kw.taxon.map(&:content))
+                end.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
+end

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

@@ -0,0 +1,23 @@
+require_relative "bibtex/from_bibtex"
+require_relative "bibtex/to_bibtex"
+
+module Relaton
+  module Bib
+    module Converter
+      module Bibtex
+        # ItemData -> BibTeX::Bibliography
+        def self.from_item(item, bibtex = nil)
+          ToBibtex.new(item).transform(bibtex)
+        end
+
+        # BibTeX string -> Hash{String=>ItemData}
+        def self.to_item(bibtex_str)
+          BibTeX.parse(bibtex_str).reduce({}) do |h, bt|
+            h[bt.key] = FromBibtex.new(bt).transform
+            h
+          end
+        end
+      end
+    end
+  end
+end