bibtex_to_scrapbox 0.2.0 → 0.2.1

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/entry/bibtexml_converter.rb

@@ -1,44 +0,0 @@
-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| field.add_element(n.to_xml) }
-      else
-        field.text = value.to_s(options)
-      end
-
-      entry.add_element(field)
-    end
-  end
-
-  protected
-
-  attr_reader :bibtex, :options
-
-  def entry
-    @entry ||= REXML::Element.new("bibtex:#{bibtex.type}")
-  end
-end

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/entry/citeproc_converter.rb

@@ -1,164 +0,0 @@
-class BibTeX::Entry::CiteProcConverter
-  CSL_FILTER = Hash.new { |h, k| k }.merge(Hash[*%w{
-    date         issued
-    isbn         ISBN
-    booktitle    container-title
-    journal      container-title
-    journaltitle container-title
-    series       collection-title
-    address      publisher-place
-    pages        page
-    number       issue
-    url          URL
-    doi          DOI
-    year         issued
-    type         genre
-    school       publisher
-    institution  publisher
-    organization publisher
-    howpublished publisher
-    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
-    phdthesis      thesis
-    proceedings    book
-    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|
-      convert key, value
-    end
-
-    bibtex.inherited_fields.each do |key|
-      convert key, bibtex.parent.provide(key)
-    end
-
-    methods = self.class.instance_methods(false) - [:convert!, :hash]
-    methods.each { |m| send(m) }
-
-    hash
-  end
-
-  def conferences
-    return unless [:conference, :proceedings, :inproceedings].include?(bibtex.type)
-
-    if bibtex.field?(:organization) && bibtex.field?(:publisher)
-      hash['authority'] = bibtex[:organization]
-      hash['publisher'] = bibtex[:publisher]
-    end
-
-    if bibtex.field? :address
-      hash['event-place'] = bibtex[:address]
-    end
-  end
-
-  def techreport
-    return unless [:techreport, :report].include?(bibtex.type)
-    hash['number'] = bibtex[:number].to_s if bibtex.field? :number
-  end
-
-  def date
-    case
-    when bibtex.field?(:date)
-      hash['issued'] = {
-        'date-parts' => bibtex.date.to_s.split('/').map { |part|
-          part.split('-').map(&:to_i)
-        }
-      }
-
-    when 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?
-
-          if bibtex.field?(:day)
-            parts.push bibtex[:day]
-          end
-        end
-
-        hash['issued'] = { 'date-parts' => [parts.compact.map(&:to_i)] }
-      else
-        hash['issued'] = { 'literal' => bibtex[:year].to_s }
-      end
-
-    else
-      # no date present
-    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 convert(key, value)
-    return if BibTeX::Entry::DATE_FIELDS.include?(key)
-
-    cp_key = CSL_FILTER[key].to_s
-
-    if hash.key?(cp_key)
-      hash[key] = value.to_citeproc(options)
-    else
-      hash[cp_key] = value.to_citeproc(options)
-    end
-  end
-
-  def hash
-    @hash ||= {}
-  end
-end

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/entry/rdf_converter.rb

@@ -1,588 +0,0 @@
-require 'uri/common'
-
-begin
-  require 'rdf/vocab'
-rescue LoadError
-  ::RDF::Vocab = RDF # support RDF on Ruby 1.9
-end
-
-class BibTeX::Entry::RDFConverter
-  DEFAULT_REMOVE_FROM_FALLBACK = %w(
-    bdsk-file-1
-    bdsk-file-2
-    bdsk-file-3
-    bdsk-file-4
-  ).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::Vocab::DC.abstract, bibtex[:abstract].to_s]
-    graph << [entry, bibo[:abstract], bibtex[:abstract].to_s]
-  end
-
-  def annote
-    return unless bibtex.field?(:annote)
-    remove_from_fallback(:annote)
-
-    pub = RDF::Node.new
-    graph << [pub, RDF.type, bibo[:Note]]
-    graph << [pub, bibo[:content], bibtex[:annote]]
-
-    graph << [entry, bibo[:annotates], pub]
-  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::Vocab::DC.creator, node]
-      graph << [seq, RDF.li, node]
-    end
-  end
-
-  def bdsk_url
-    count = 1
-    while bibtex.field?("bdsk-url-#{count}".to_sym) do
-      field = "bdsk-url-#{count}".to_sym
-      remove_from_fallback(field)
-      graph << [entry, RDF::Vocab::DC.URI, bibtex[field].to_s]
-      graph << [entry, bibo[:uri], bibtex[field].to_s]
-      count  += 1
-    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::Vocab::DC.title, bibtex[:booktitle].to_s]
-
-    graph << [entry, RDF::Vocab::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::Vocab::DC.hasPart, child_id]
-    end
-  end
-
-  def copyright
-    return unless bibtex.field?(:copyright)
-    remove_from_fallback(:copyright)
-
-    graph << [entry, RDF::Vocab::DC.rightsHolder, bibtex[:copyright].to_s]
-  end
-
-  def date_added
-    return unless bibtex.field?(:'date-added')
-    remove_from_fallback(:'date-added')
-
-    graph << [entry, RDF::Vocab::DC.created, bibtex[:'date-added'].to_s]
-  end
-
-  def date_modified
-    return unless bibtex.field?(:'date-modified')
-    remove_from_fallback(:'date-modified')
-
-    graph << [entry, RDF::Vocab::DC.modified, bibtex[:'date-modified'].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::Vocab::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::Vocab::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::Vocab::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::Vocab::DC.isPartOf, "urn:isbn:#{bibtex[:isbn].to_s}"]
-    else
-      graph << [entry, RDF::Vocab::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::Vocab::DC.isPartOf, "urn:issn:#{bibtex[:issn].to_s}"]
-    else
-      graph << [entry, RDF::Vocab::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::Vocab::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::Vocab::DC.title, bibtex[:journal].to_s]
-
-    graph << [entry, RDF::Vocab::DC.isPartOf, journal]
-  end
-
-  def key
-    graph << [entry, RDF::Vocab::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::Vocab::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::Vocab::DC.language, bibtex[:language].to_s]
-  end
-
-  def location
-    return unless bibtex.field?(:location)
-    remove_from_fallback(:location)
-
-    graph << [entry, RDF::Vocab::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::Vocab::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::Vocab::DC.isPartOf, parent_id]
-  end
-
-  def publisher
-    return unless bibtex.field?(:publisher, :organization, :school, :institution)
-    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) }
-      when bibtex.field?(:institution)
-        agent(bibtex[:institution].to_s) { create_agent(bibtex[:institution].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::Vocab::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::Vocab::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::Vocab::DC.title, bibtex[:series].to_s]
-
-    graph << [entry, RDF::Vocab::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 /Dissertation/i 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
-
-    unless degree.nil?
-      remove_from_fallback(:type)
-      graph << [entry, bibo[:degree], degree]
-    end
-  end
-
-  def title
-    return unless bibtex.field?(:title)
-    remove_from_fallback(:title)
-
-    title = [bibtex[:title].to_s, bibtex[:subtitle].to_s]
-      .reject { |t| t.nil? || t.empty? }
-      .join(': ')
-    graph << [entry, RDF::Vocab::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::Vocab::DC.contributor, node]
-    graph << [entry, bibo[:translator], node]
-  end
-
-  def type
-    graph << [entry, RDF.type, bibo[bibo_class]]
-
-    case bibtex.type
-    when :proceedings, :journal
-      graph << [entry, RDF::Vocab::DC.type, 'Collection']
-    else
-      graph << [entry, RDF::Vocab::DC.type, 'Text']
-    end
-  end
-
-  def url
-    return unless bibtex.field?(:url)
-    remove_from_fallback(:url)
-
-    graph << [entry, RDF::Vocab::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 = month.nil? ? year : [year, month].join('-')
-
-    graph << [entry, RDF::Vocab::DC.issued, date]
-  end
-
-  protected
-
-  attr_reader :bibtex, :graph
-
-  private
-
-  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::Vocab::FOAF[type]]
-    graph << [node, RDF::Vocab::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