bibtex-ruby 3.0.1 → 3.1.0

data/lib/bibtex/entry/bibtexml_converter.rb

@@ -0,0 +1,44 @@
+require 'rexml/document'
+
+class BibTeX::Entry::BibTeXMLConverter
+  def self.convert(bibtex, options = {})
+    new(bibtex, options).convert!
+  end
+
+  def initialize(bibtex, options = {})
+    @bibtex = bibtex
+    @options = options
+  end
+
+  def convert!
+    xml = REXML::Element.new('bibtex:entry')
+    xml.attributes['id'] = bibtex.key
+
+    fields
+
+    xml.add_element(entry)
+    xml
+  end
+
+  def fields
+    bibtex.fields.each do |key, value|
+      field = REXML::Element.new("bibtex:#{key}")
+
+      if options[:extended] && value.name?
+        value.each { |n| entry.add_element(n.to_xml) }
+      else
+        field.text = value.to_s(options)
+      end
+
+      entry.add_element(field)
+    end
+  end
+
+  private
+
+  attr_reader :bibtex, :options
+
+  def entry
+    @entry ||= REXML::Element.new("bibtex:#{bibtex.type}")
+  end
+end

data/lib/bibtex/entry/citeproc_converter.rb

@@ -0,0 +1,110 @@
+class BibTeX::Entry::CiteProcConverter
+  CSL_FILTER = Hash.new { |h, k| k }.merge(Hash[*%w{
+    date      issued
+    isbn      ISBN
+    booktitle container-title
+    journal   container-title
+    series    collection-title
+    address   publisher-place
+    pages     page
+    number    issue
+    url       URL
+    doi       DOI
+    year      issued
+    type      genre
+  }.map(&:intern)]).freeze
+
+  CSL_FIELDS = %w{
+    abstract annote archive archive_location archive-place
+    authority call-number chapter-number citation-label citation-number
+    collection-title container-title DOI edition event event-place
+    first-reference-note-number genre ISBN issue jurisdiction keyword locator
+    medium note number number-of-pages number-of-volumes original-publisher
+    original-publisher-place original-title page page-first publisher
+    publisher-place references section status title URL version volume
+    year-suffix accessed container event-date issued original-date
+    author editor translator recipient interviewer publisher composer
+    original-publisher original-author container-author collection-editor
+  }.map(&:intern).freeze
+
+  CSL_TYPES = Hash.new { |h, k| k }.merge(Hash[*%w{
+    booklet        pamphlet
+    conference     paper-conference
+    inbook         chapter
+    incollection   chapter
+    inproceedings  paper-conference
+    manual         book
+    mastersthesis  thesis
+    misc           article
+    phdthesis      thesis
+    proceedings    paper-conference
+    techreport     report
+    unpublished    manuscript
+    article        article-journal
+  }.map(&:intern)]).freeze
+
+  def self.convert(bibtex, options = {})
+    new(bibtex, options).convert!
+  end
+
+  def initialize(bibtex, options = {})
+    @bibtex = bibtex
+    @options = { quotes: [] }.merge(options)
+  end
+
+  def convert!
+    bibtex.parse_names
+    bibtex.parse_month
+
+    bibtex.each_pair do |key, value|
+      hash[CSL_FILTER[key].to_s] = value.to_citeproc(options) unless BibTeX::Entry::DATE_FIELDS.include?(key)
+    end
+
+    methods = self.class.instance_methods(false) - [:convert!]
+    methods.each { |m| send(m) }
+
+    hash
+  end
+
+  def date
+    return unless bibtex.field?(:year)
+
+    case bibtex[:year].to_s
+    when /^\d+$/
+      parts = [bibtex[:year].to_s]
+
+      if bibtex.field?(:month)
+        parts.push BibTeX::Entry::MONTHS.find_index(bibtex[:month].to_s.intern)
+        parts[1] = parts[1] + 1 unless parts[1].nil?
+      end
+
+      hash['issued'] = { 'date-parts' => [parts.compact.map(&:to_i)] }
+    else
+      hash['issued'] = { 'literal' => bibtex[:year].to_s }
+    end
+  end
+
+  def key
+    hash['id'] = bibtex.key.to_s
+  end
+
+  def type
+    hash['type'] = CSL_TYPES[bibtex.type].to_s
+
+    return if hash.key?('genre')
+    case bibtex.type
+    when :mastersthesis
+      hash['genre'] = "Master's thesis"
+    when :phdthesis
+      hash['genre'] = 'PhD thesis'
+    end
+  end
+
+  private
+
+  attr_reader :bibtex, :options
+
+  def hash
+    @hash ||= {}
+  end
+end

data/lib/bibtex/entry/rdf_converter.rb

@@ -0,0 +1,543 @@
+require 'uri/common'
+
+class BibTeX::Entry::RDFConverter
+  DEFAULT_REMOVE_FROM_FALLBACK = %w(
+    date-modified
+    bdsk-file-1
+    bdsk-file-2
+    bdsk-file-3
+  ).map(&:intern).freeze
+
+  BIBO_TYPES = Hash[*%w{
+    article        Article
+    book           Book
+    booklet        Book
+    collection     Collection
+    conference     AcademicArticle
+    inbook         BookSection
+    incollection   BookSection
+    inproceedings  AcademicArticle
+    journal        Journal
+    manual         Manual
+    mastersthesis  Thesis
+    online         Website
+    patent         Patent
+    periodical     Periodical
+    phdthesis      Thesis
+    proceedings    Proceedings
+    standard       Standard
+    techreport     Report
+    thesis         Thesis
+    unpublished    Manuscript
+  }.map(&:intern)].freeze
+
+  # converts a BibTeX entry to RDF
+  # @return [RDF::Graph] the RDF graph of this entry
+  def self.convert(bibtex, graph = RDF::Graph.new, agent = {})
+    new(bibtex, graph, agent).convert!
+  end
+
+  # @param [BibTeX::Entry] the entry to convert
+  def initialize(bibtex, graph = RDF::Graph.new, agent = {})
+    @bibtex = bibtex
+    @graph = graph
+    @agent = agent
+  end
+
+  # @return [RDF::Graph] the RDF graph of this entry
+  def convert!
+    bibtex.parse_names
+    bibtex.parse_month
+
+    unless uri_in_graph?(entry)
+      methods = self.class.instance_methods(false) - [:convert!]
+      methods.each { |m| send(m) }
+      run_fallback
+    end
+
+    graph
+  end
+
+  def abstract
+    return unless bibtex.field?(:abstract)
+    remove_from_fallback(:abstract)
+
+    graph << [entry, RDF::DC.abstract, bibtex[:abstract].to_s]
+    graph << [entry, bibo[:abstract], bibtex[:abstract].to_s]
+  end
+
+  def author
+    return unless bibtex.field?(:author)
+    remove_from_fallback(:author)
+
+    seq = RDF::Node.new
+
+    graph << [seq, RDF.type, RDF[:Seq]]
+    graph << [entry, bibo[:authorList], seq]
+
+    bibtex[:author].each do |name|
+      node = agent(name) { create_agent(name, :Person) }
+
+      graph << [entry, RDF::DC.creator, node]
+      graph << [seq, RDF.li, node]
+    end
+  end
+
+  def booktitle
+    return unless bibtex.field?(:booktitle)
+    remove_from_fallback(:booktitle)
+    return if bibtex.has_parent? &&
+      bibtex.parent[:title] == bibtex[:booktitle]
+    return if bibtex.has_parent? &&
+      bibtex.parent[:booktitle] == bibtex[:booktitle]
+    return if bibtex.has_parent? &&
+      bibtex.parent[:isbn] == bibtex[:isbn]
+    return if bibtex[:title] == bibtex[:booktitle]
+
+    series = RDF::Node.new
+    graph << [series, RDF.type, bibo[:Document]]
+    graph << [series, RDF::DC.title, bibtex[:booktitle].to_s]
+
+    graph << [entry, RDF::DC.isPartOf, series]
+  end
+
+  def chapter
+    return unless bibtex.field?(:chapter)
+    remove_from_fallback(:chapter)
+
+    graph << [entry, bibo[:chapter], bibtex[:chapter].to_s]
+  end
+
+  def children
+    return unless bibtex.has_children?
+
+    bibtex.children.each do |child|
+      child_id = RDF::URI.new(child.identifier)
+      BibTeX::Entry::RDFConverter.new(child, graph, agent).convert! unless uri_in_graph?(child_id)
+      graph << [entry, RDF::DC.hasPart, child_id]
+    end
+  end
+
+  def copyright
+    return unless bibtex.field?(:copyright)
+    remove_from_fallback(:copyright)
+
+    graph << [entry, RDF::DC.rightsHolder, bibtex[:copyright].to_s]
+  end
+
+  def date_added
+    return unless bibtex.field?(:'date-added')
+    remove_from_fallback(:'date-added')
+
+    graph << [entry, RDF::DC.created, bibtex[:'date-added'].to_s]
+  end
+
+  def doi
+    return unless bibtex.field?(:doi)
+    remove_from_fallback(:doi)
+
+    graph << [entry, bibo[:doi], bibtex[:doi].to_s]
+    graph << [entry, RDF::DC.identifier, "doi:#{bibtex[:doi].to_s}"]
+  end
+
+  def edition
+    return unless bibtex.field?(:edition)
+    remove_from_fallback(:edition)
+
+    graph << [entry, bibo[:edition], bibtex[:edition].to_s]
+  end
+
+  def editor
+    return unless bibtex.field?(:editor)
+    remove_from_fallback(:editor)
+
+    seq = RDF::Node.new
+
+    graph << [seq, RDF.type, RDF[:Seq]]
+    graph << [entry, bibo[:editorList], seq]
+
+    bibtex[:editor].each do |name|
+      node = agent(name) { create_agent(name, :Person) }
+
+      graph << [entry, bibo.name, node]
+      graph << [seq, RDF.li, node]
+    end
+  end
+
+  def fallback_default
+    remove_from_fallback(*DEFAULT_REMOVE_FROM_FALLBACK)
+  end
+
+  def howpublished
+    return unless bibtex.field?(:howpublished)
+    return unless bibtex[:howpublished] =~ /^#{URI.regexp}$/
+    remove_from_fallback(:howpublished)
+
+    graph << [entry, RDF::DC.URI, bibtex[:howpublished].to_s]
+    graph << [entry, bibo[:uri], bibtex[:howpublished].to_s]
+  end
+
+  def institution
+    return unless bibtex.field?(:institution)
+    remove_from_fallback(:institution)
+
+    org = agent(bibtex[:institution].to_s) { create_agent(bibtex[:institution].to_s, :Organization) }
+
+    graph << [entry, RDF::DC.contributor, org]
+  end
+
+  def isbn
+    return unless bibtex.field?(:isbn)
+    remove_from_fallback(:isbn)
+
+    graph << [entry, bibo[:isbn], bibtex[:isbn].to_s]
+
+    if bibtex.contained?
+      graph << [entry, RDF::DC.isPartOf, "urn:isbn:#{bibtex[:isbn].to_s}"]
+    else
+      graph << [entry, RDF::DC.identifier, "urn:isbn:#{bibtex[:isbn].to_s}"]
+    end
+  end
+
+  def issn
+    return unless bibtex.field?(:issn)
+    remove_from_fallback(:issn)
+
+    graph << [entry, bibo[:issn], bibtex[:issn].to_s]
+    if bibtex.contained?
+      graph << [entry, RDF::DC.isPartOf, "urn:issn:#{bibtex[:issn].to_s}"]
+    else
+      graph << [entry, RDF::DC.identifier, "urn:issn:#{bibtex[:issn].to_s}"]
+    end
+  end
+
+  def journal_dc_source
+    return unless bibtex.field?(:journal)
+    remove_from_fallback(:journal)
+
+    source = []
+    source << bibtex[:journal].to_s
+    source << "Vol. #{bibtex[:volume].to_s}" if bibtex.field?(:volume)
+    source << "No. #{bibtex[:number].to_s}" if bibtex.field?(:number)
+    pagination = bibtex[:pagination] || 'pp.'
+    source << "#{pagination.to_s} #{bibtex[:pages].to_s}" if bibtex.field?(:pages)
+    graph << [entry, RDF::DC.source, source.join(', ')]
+  end
+
+  def journal_dc_part_of
+    return unless bibtex.field?(:journal)
+    return if bibtex.has_parent? && bibtex.parent[:title] == bibtex[:journal]
+    return if bibtex.has_parent? && bibtex.parent[:issn] == bibtex[:issn]
+
+    journal = RDF::Node.new
+    graph << [journal, RDF.type, bibo[:Journal]]
+    graph << [journal, RDF::DC.title, bibtex[:journal].to_s]
+
+    graph << [entry, RDF::DC.isPartOf, journal]
+  end
+
+  def key
+    graph << [entry, RDF::DC.identifier, "urn:bibtex:#{bibtex.key}"]
+  end
+
+  def keywords
+    return unless bibtex.field?(:keywords)
+    remove_from_fallback(:keywords)
+
+    bibtex[:keywords].to_s.split(/\s*,\s*/).each do |keyword|
+      graph << [entry, RDF::DC.subject, keyword]
+    end
+  end
+
+  def language
+    return unless bibtex.field?(:language)
+    remove_from_fallback(:language)
+
+    bibtex[:language] = 'german' if bibtex[:language] == 'ngerman'
+
+    graph << [entry, RDF::DC.language, bibtex[:language].to_s]
+  end
+
+  def location
+    return unless bibtex.field?(:location)
+    remove_from_fallback(:location)
+
+    graph << [entry, RDF::DC.Location, bibtex[:location].to_s]
+    if [:proceedings, :inproceedings, :conference].include?(bibtex.type)
+      event = RDF::Vocabulary.new('http://purl.org/NET/c4dm/event.owl')
+      graph << [entry, event[:place], org]
+    end
+  end
+
+  def lccn
+    return unless bibtex.field?(:lccn)
+    remove_from_fallback(:lccn)
+
+    graph << [entry, bibo[:lccn], bibtex[:lccn].to_s]
+  end
+
+  def note
+    return unless bibtex.field?(:note)
+    remove_from_fallback(:note)
+
+    pub = RDF::Node.new
+    graph << [pub, RDF.type, bibo[:Note]]
+    graph << [pub, bibo[:content], bibtex[:note]]
+
+    graph << [entry, bibo[:annotates], pub]
+  end
+
+  def number
+    return unless bibtex.field?(:number)
+    remove_from_fallback(:number)
+
+    case bibtex.type
+    when :techreport || :manual || :unpublished
+      graph << [entry, bibo[:number], bibtex[:number].to_s]
+    else
+      graph << [entry, bibo[:issue], bibtex[:number].to_s]
+    end
+  end
+
+  def organization
+    return unless bibtex.field?(:organization)
+    remove_from_fallback(:organization)
+
+    org = agent(bibtex[:organization].to_s) { create_agent(bibtex[:organization].to_s, :Organization) }
+
+    graph << [entry, RDF::DC.contributor, org]
+    graph << [entry, bibo[:organizer], org] if [:proceedings, :inproceedings, :conference].include?(bibtex.type)
+  end
+
+  def pages
+    return unless bibtex.field?(:pages)
+    remove_from_fallback(:pages)
+
+    if bibtex[:pages].to_s =~ /^\s*(\d+)\s*-+\s*(\d+)\s*$/
+      graph << [entry, bibo[:pageStart], Regexp.last_match[1]]
+      graph << [entry, bibo[:pageEnd], Regexp.last_match[2]]
+    else
+      graph << [entry, bibo[:pages], bibtex[:pages].to_s]
+    end
+  end
+
+  def pagetotal
+    return unless bibtex.field?(:pagetotal)
+    remove_from_fallback(:pagetotal)
+
+    graph << [entry, bibo[:numPages], bibtex[:pagetotal].to_s]
+  end
+
+  def parent
+    return unless bibtex.has_parent?
+    remove_from_fallback(:crossref)
+
+    parent_id = RDF::URI.new(bibtex.parent.identifier)
+    BibTeX::Entry::RDFConverter.new(bibtex.parent, graph, agent).convert! unless uri_in_graph?(parent_id)
+    graph << [entry, RDF::DC.isPartOf, parent_id]
+  end
+
+  def publisher
+    return unless bibtex.field?(:publisher) || bibtex.field?(:organization) || bibtex.field?(:school)
+    remove_from_fallback(:publisher, :address)
+
+    org =
+      case
+      when bibtex.field?(:publisher)
+        agent(bibtex[:publisher].to_s) { create_agent(bibtex[:publisher].to_s, :Organization) }
+      when bibtex.field?(:organization)
+        agent(bibtex[:organization].to_s) { create_agent(bibtex[:organization].to_s, :Organization) }
+      when bibtex.field?(:school)
+        agent(bibtex[:school].to_s) { create_agent(bibtex[:school].to_s, :Organization) }
+      end
+
+    if bibtex.field?(:address)
+      address = RDF::Vocabulary.new('http://schemas.talis.com/2005/address/schema#')
+      graph << [org, address[:localityName], bibtex[:address]]
+    end
+
+    graph << [entry, RDF::DC.publisher, org]
+    graph << [entry, bibo[:publisher], org]
+  end
+
+  def school
+    return unless bibtex.field?(:school)
+    remove_from_fallback(:school)
+
+    org = agent(bibtex[:school].to_s) { create_agent(bibtex[:school].to_s, :Organization) }
+
+    graph << [entry, RDF::DC.contributor, org]
+  end
+
+  def series
+    return unless bibtex.field?(:series)
+    remove_from_fallback(:series)
+    return if bibtex.has_parent? && bibtex.parent[:title] == bibtex[:series]
+    return if bibtex.has_parent? && bibtex.parent[:series] == bibtex[:series]
+    return if bibtex.has_parent? && bibtex.parent[:issn] == bibtex[:issn]
+
+    series = RDF::Node.new
+    graph << [series, RDF.type, bibo[:MultiVolumeBook]]
+    graph << [series, RDF::DC.title, bibtex[:series].to_s]
+
+    graph << [entry, RDF::DC.isPartOf, series]
+  end
+
+  def thesis_degree
+    return unless bibo_class == :Thesis
+
+    degree =
+      case bibtex.type
+      # ms = masters degree in science
+      # Only ma and ms available. We simply chose one.
+      when :mastersthesis then bibo['degrees/ms']
+      when :phdthesis then bibo['degrees/phd']
+      end
+
+    degree =
+      case bibtex[:type]
+      when 'mathesis' then bibo['degrees/ma']
+      when 'phdthesis' then bibo['degrees/phd']
+      when /Bachelor['s]{0,2} Thesis/i then "Bachelor's Thesis"
+      when /Diplomarbeit/i then bibo['degrees/ms']
+      when /Magisterarbeit/i then bibo['degrees/ma']
+      else degree
+      end
+
+    graph << [entry, bibo[:degree], degree] unless degree.nil?
+  end
+
+  def title
+    return unless bibtex.field?(:title)
+    remove_from_fallback(:title)
+
+    title = [bibtex[:title].to_s, bibtex[:subtitle].to_s].join(': ')
+    graph << [entry, RDF::DC.title, title]
+    graph << [entry, bibo[:shortTitle], bibtex[:title].to_s] if bibtex.field?(:subtitle)
+  end
+
+  def translator
+    return unless bibtex.field?(:translator)
+    remove_from_fallback(:translator)
+
+    node = agent(bibtex[:translator].to_s) do
+      create_agent(bibtex[:translator].to_s, :Person)
+    end
+
+    graph << [entry, RDF::DC.contributor, node]
+    graph << [entry, bibo[:translator], node]
+  end
+
+  def type
+    graph << [entry, RDF.type, bibo_class]
+
+    case bibtex.type
+    when :proceedings, :journal
+      graph << [entry, RDF::DC.type, 'Collection']
+    else
+      graph << [entry, RDF::DC.type, 'Text']
+    end
+  end
+
+  def url
+    return unless bibtex.field?(:url)
+    remove_from_fallback(:url)
+
+    graph << [entry, RDF::DC.URI, bibtex[:url].to_s]
+    graph << [entry, bibo[:uri], bibtex[:url].to_s]
+  end
+
+  def volume
+    return unless bibtex.field?(:volume)
+    remove_from_fallback(:volume)
+
+    graph << [entry, bibo[:volume], bibtex[:volume].to_s]
+  end
+
+  def volumes
+    return unless bibtex.field?(:volumes)
+    remove_from_fallback(:volumes)
+
+    graph << [entry, bibo[:numVolumes], bibtex[:volumes].to_s]
+  end
+
+  def year
+    return unless bibtex.field?(:year)
+    remove_from_fallback(:year, :month)
+
+    year = bibtex[:year].to_s
+    if bibtex.field?(:month)
+      month = BibTeX::Entry::MONTHS.find_index(bibtex[:month].to_s.intern)
+      month += 1 unless month.nil?
+    end
+    date = [year, month].join('-')
+
+    graph << [entry, RDF::DC.issued, date]
+  end
+
+  private
+
+  attr_reader :bibtex, :graph
+
+  def bibo
+    @bibo ||= RDF::Vocabulary.new('http://purl.org/ontology/bibo/')
+  end
+
+  def bibo_class
+    BIBO_TYPES[bibtex[:type]] || BIBO_TYPES[bibtex.type] || :Document
+  end
+
+  def entry
+    @entry ||= RDF::URI.new(bibtex.identifier)
+  end
+
+  def agent(key = nil, &block)
+    if key.nil?
+      @agent
+    else
+      key = key.respond_to?(:to_hash) ? key.to_hash : key
+      @agent[key] ||= yield
+    end
+  end
+
+  def create_agent(name, type)
+    node = RDF::Node.new
+
+    graph << [node, RDF.type, RDF::FOAF[type]]
+    graph << [node, RDF::FOAF.name, name.to_s]
+
+    if name.is_a?(BibTeX::Name)
+      [:given, :family, :prefix, :suffix].each do |part|
+        value = name.send(part)
+        graph << [node, bibo["#{part}Name"], value.to_s] unless value.nil?
+      end
+    end
+
+    node
+  end
+
+  def uri_in_graph?(uri)
+    solutions = RDF::Query.execute(graph) do
+      pattern [uri, nil, nil]
+    end
+
+    solutions.size > 0
+  end
+
+  def fallback
+    @fallback ||= bibtex.fields.keys
+  end
+
+  def remove_from_fallback(*fields)
+    fields.each { |field| fallback.delete(field) }
+  end
+
+  def run_fallback
+    return if fallback.empty?
+
+    ml = RDF::Vocabulary.new('http://bibtexml.sf.net/')
+    fallback.each do |field|
+      graph << [entry, ml[field], bibtex[field]]
+    end
+  end
+end