bibtex_to_scrapbox 0.1.0

data/gems/gems/bibtex-ruby-4.4.4/test/benchmark.rb

@@ -0,0 +1,84 @@
+# ruby -Ilib -rrubygems test/benchmark.rb
+
+require 'benchmark'
+include Benchmark
+
+require 'bibtex'
+
+# data = File.open(BibTeX::Test.fixtures(:benchmark)).read
+
+input = <<-END
+@book{pickaxe,
+	Address = {Raleigh, North Carolina},
+	Author = {Thomas, Dave, and Fowler, Chad, and Hunt, Andy},
+	Date-Added = {2010-08-05 09:54:07 +0200},
+	Date-Modified = {2010-08-05 10:07:01 +0200},
+	Keywords = {ruby},
+	Publisher = {The Pragmatic Bookshelf},
+	Series = {The Facets of Ruby},
+	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
+	Year = {2009}
+}
+END
+
+n, k = 31, 10
+lexer = BibTeX::Lexer.new
+# parser = BibTeX::Parser.new
+
+f = []
+g = []
+
+# Ruby 1.9.3
+format = Benchmark.const_defined?(:FMTSTR) ? Benchmark::FMTSTR : Benchmark::FORMAT
+
+Benchmark.benchmark((" "*15) + CAPTION, 7, format, '%14s:' % 'sum(f)', '%14s:' % 'sum(g)') do |b|
+
+  1.step(n,k) do |i|
+
+    f << b.report('%14s:' % "f(#{i})") do
+      i.times do
+        lexer.data = input
+        lexer.analyse
+				# BibTeX::Parser.new.parse(input)
+      end
+    end
+
+    data = input * i
+
+    g << b.report('%14s:' % "g(#{i})") do
+      lexer.data = data
+      lexer.analyse
+			# BibTeX::Parser.new.parse(data)
+    end
+
+  end
+
+  [f.inject(:+), g.inject(:+)]
+end
+
+# require 'gnuplot'
+#
+# f = f.map(&:total)
+# g = g.map(&:total)
+#
+# x = 1.step(n,k).to_a
+#
+# Gnuplot.open do |gp|
+#   Gnuplot::Plot.new(gp) do |plot|
+#
+#     plot.title  'BibTeX-Ruby Benchmark'
+#     plot.ylabel 't'
+#     plot.xlabel 'n'
+#
+#     plot.data << Gnuplot::DataSet.new([x,f]) do |ds|
+#       ds.with = 'linespoints'
+#       ds.title = 'f'
+#     end
+#
+#     plot.data << Gnuplot::DataSet.new([x,g]) do |ds|
+#       ds.with = 'linespoints'
+#       ds.title = 'g'
+#     end
+#
+#   end
+# end

data/gems/gems/bibtex-ruby-4.4.4/test/bibtex/entry/test_rdf_converter.rb

@@ -0,0 +1,341 @@
+# -*- coding: utf-8 -*-
+
+require 'helper.rb'
+
+module BibTeX
+  class RDFConverterTest < Minitest::Spec
+    subject { BibTeX::Entry::RDFConverter.new(entry) }
+    let(:entry) { Entry.new }
+
+    before do
+      entry.parse_names
+      entry.parse_month
+    end
+
+    describe '#abstract' do
+      let(:entry) { Entry.new(abstract: 'foo') }
+
+      it 'should run successfully' do
+        subject.abstract
+      end
+    end
+
+    describe '#annote' do
+      let(:entry) { Entry.new(annote: 'foo') }
+
+      it 'should run successfully' do
+        subject.annote
+      end
+    end
+
+    describe '#author' do
+      let(:entry) { Entry.new(author: 'Gustav Gans and Donald Duck') }
+
+      it 'should run successfully' do
+        subject.author
+      end
+    end
+
+    describe '#bdsk_url' do
+      let(:entry) { Entry.new(:'bdsk-url-1' => 'http://www.example.com') }
+
+      it 'should run successfully' do
+        subject.bdsk_url
+      end
+    end
+
+    describe '#booktitle' do
+      let(:entry) { Entry.new(booktitle: 'Entenhausen brennt!') }
+
+      it 'should run successfully' do
+        subject.booktitle
+      end
+    end
+
+    describe '#chapter' do
+      let(:entry) { Entry.new(chapter: '4') }
+
+      it 'should run successfully' do
+        subject.chapter
+      end
+    end
+
+    describe '#children' do
+      it 'should run successfully'
+    end
+
+    describe '#copyright' do
+      let(:entry) { Entry.new(copyright: 'King Kong') }
+
+      it 'should run successfully' do
+        subject.copyright
+      end
+    end
+
+    describe '#date_added' do
+      let(:entry) { Entry.new(:'date-added' => '2014-01-20') }
+
+      it 'should run successfully' do
+        subject.date_added
+      end
+    end
+
+    describe '#date_modified' do
+      let(:entry) { Entry.new(:'date-modified' => '2014-01-20') }
+
+      it 'should run successfully' do
+        subject.date_modified
+      end
+    end
+
+    describe '#doi' do
+      let(:entry) { Entry.new(doi: '10.1000/182') }
+
+      it 'should run successfully' do
+        subject.doi
+      end
+    end
+
+    describe '#edition' do
+      let(:entry) { Entry.new(edition: 'fifth edition') }
+
+      it 'should run successfully' do
+        subject.edition
+      end
+    end
+
+    describe '#editor' do
+      let(:entry) { Entry.new(editor: 'Dagobert Duck') }
+
+      it 'should run successfully' do
+        subject.editor
+      end
+    end
+
+    describe '#fallback_default' do
+      it 'should run successfully' do
+        subject.fallback_default
+      end
+    end
+
+    describe '#howpublished' do
+      let(:entry) { Entry.new(howpublished: 'http://www.example.com') }
+
+      it 'should run successfully' do
+        subject.howpublished
+      end
+    end
+
+    describe '#institution' do
+      let(:entry) { Entry.new(institution: 'University of Duckberg') }
+
+      it 'should run successfully' do
+        subject.institution
+      end
+    end
+
+    describe '#isbn' do
+      let(:entry) { Entry.new(isbn: '978-3-935322-14-0') }
+
+      it 'should run successfully' do
+        subject.isbn
+      end
+    end
+
+    describe '#issn' do
+      let(:entry) { Entry.new(issn: '978-3-935322-14-0') }
+
+      it 'should run successfully' do
+        subject.issn
+      end
+    end
+
+    describe '#journal_dc_source' do
+      let(:entry) { Entry.new(journal: 'Lustiges Taschenbuch') }
+
+      it 'should run successfully' do
+        subject.journal_dc_source
+      end
+    end
+
+    describe '#journal_dc_part_of' do
+      let(:entry) { Entry.new(journal: 'Lustiges Taschenbuch') }
+
+      it 'should run successfully' do
+        subject.journal_dc_part_of
+      end
+    end
+
+    describe '#key' do
+      let(:entry) { Entry.new(key: 'pickaxe') }
+
+      it 'should run successfully' do
+        subject.key
+      end
+    end
+
+    describe '#keywords' do
+      let(:entry) { Entry.new(keywords: 'Ruby, RDF, Fun') }
+
+      it 'should run successfully' do
+        subject.keywords
+      end
+    end
+
+    describe '#language' do
+      let(:entry) { Entry.new(language: 'french') }
+
+      it 'should run successfully' do
+        subject.language
+      end
+    end
+
+    describe '#location' do
+      let(:entry) { Entry.new(location: 'Duckberg') }
+
+      it 'should run successfully' do
+        subject.location
+      end
+    end
+
+    describe '#lccn' do
+      let(:entry) { Entry.new(lccn: '1234') }
+
+      it 'should run successfully' do
+        subject.lccn
+      end
+    end
+
+    describe '#note' do
+      let(:entry) { Entry.new(note: 'Never gonna give you up!') }
+
+      it 'should run successfully' do
+        subject.note
+      end
+    end
+
+    describe '#number' do
+      let(:entry) { Entry.new(number: '2') }
+
+      it 'should run successfully' do
+        subject.number
+      end
+    end
+
+    describe '#organization' do
+      let(:entry) { Entry.new(organization: 'Azkaban Prison') }
+
+      it 'should run successfully' do
+        subject.organization
+      end
+    end
+
+    describe '#pages' do
+      let(:entry) { Entry.new(pages: '1--12') }
+
+      it 'should run successfully' do
+        subject.pages
+      end
+    end
+
+    describe '#pagetotal' do
+      let(:entry) { Entry.new(pagetotal: '12') }
+
+      it 'should run successfully' do
+        subject.pagetotal
+      end
+    end
+
+    describe '#parent' do
+      it 'should run successfully'
+    end
+
+    describe '#publisher' do
+      let(:entry) { Entry.new(publisher: 'Neustaedter Zeitung') }
+
+      it 'should run successfully' do
+        subject.publisher
+      end
+    end
+
+    describe '#school' do
+      let(:entry) { Entry.new(school: 'Hogwarts School of Witchcraft and Wizardry') }
+
+      it 'should run successfully' do
+        subject.school
+      end
+    end
+
+    describe '#series' do
+      let(:entry) { Entry.new(series: 'Harry Potter') }
+
+      it 'should run successfully' do
+        subject.series
+      end
+    end
+
+    describe '#thesis_degree' do
+      let(:entry) { Entry.new(type: :thesis) }
+
+      it 'should run successfully' do
+        subject.thesis_degree
+      end
+    end
+
+    describe '#title' do
+      let(:entry) { Entry.new(title: 'My Title') }
+
+      it 'should run successfully' do
+        subject.title
+      end
+    end
+
+    describe '#translator' do
+      let(:entry) { Entry.new(translator: 'Jon Doe') }
+
+      it 'should run successfully' do
+        subject.translator
+      end
+    end
+
+    describe '#type' do
+      let(:entry) { Entry.new(type: :proceedings) }
+
+      it 'should run successfully' do
+        subject.type
+      end
+    end
+
+    describe '#url' do
+      let(:entry) { Entry.new(url: 'http://www.example.com') }
+
+      it 'should run successfully' do
+        subject.url
+      end
+    end
+
+    describe '#volume' do
+      let(:entry) { Entry.new(volume: '4') }
+
+      it 'should run successfully' do
+        subject.volume
+      end
+    end
+
+    describe '#volumes' do
+      let(:entry) { Entry.new(volumes: '7') }
+
+      it 'should run successfully' do
+        subject.volumes
+      end
+    end
+
+    describe '#year' do
+      let(:entry) { Entry.new(year: '1977', month: 'jan') }
+
+      it 'should run successfully' do
+        subject.year
+      end
+    end
+  end
+end

data/gems/gems/bibtex-ruby-4.4.4/test/bibtex/test_bibliography.rb

@@ -0,0 +1,446 @@
+# -*- encoding: utf-8 -*-
+
+require 'helper'
+
+module BibTeX
+
+  class BibliographyTest < Minitest::Spec
+
+    describe 'when newly created' do
+      it 'should not be nil' do
+        assert Bibliography.new
+      end
+      it 'should be empty' do
+        assert Bibliography.new.empty?
+      end
+    end
+
+    describe '.open' do
+      it 'accepts a block and save the file after execution' do
+        tmp = Tempfile.new('bibtex')
+        tmp.close
+        b = BibTeX.open(Test.fixtures(:bibdesk)).save_to(tmp.path)
+
+        BibTeX.open(tmp.path) do |bib|
+          bib.delete(:rails)
+        end
+
+        assert_equal b.length - 1, BibTeX.open(tmp.path).length
+      end
+
+    end
+
+    describe '.parse' do
+      it 'accepts filters' do
+        Bibliography.parse("@misc{k, title = {\\''u}}", :filter => 'latex')[0].title.must_be :==, 'ü'
+      end
+
+      it 'accepts filters in an array' do
+        Bibliography.parse("@misc{k, title = {\\''u}}", :filter => ['latex'])[0].title.must_be :==, 'ü'
+      end
+    end
+
+    describe 'given a populated biliography' do
+      before do
+        @bib = BibTeX.parse <<-END
+        @book{rails,
+          address = {Raleigh, North Carolina},
+          author = {Ruby, Sam, and Thomas, Dave, and Hansson Heinemeier, David},
+          booktitle = {Agile Web Development with Rails},
+          edition = {third},
+          keywords = {ruby, rails},
+          publisher = {The Pragmatic Bookshelf},
+          series = {The Facets of Ruby},
+          title = {Agile Web Development with Rails},
+          year = {2009}
+        }
+        @book{flanagan2008,
+          title={{The ruby programming language}},
+          author={Flanagan, D. and Matsumoto, Y.},
+          keywords = {ruby},
+          year={2008},
+          publisher={O'Reilly}
+        }
+        @article{segaran2007,
+          title={{Programming collective intelligence}},
+          author={Segaran, T.},
+          year={2007},
+          publisher={O'Reilly},
+          type={interview}
+        }
+        @string{ foo = "foobar" }
+        @misc{flanagan-1,
+          title={{Foo Bar}},
+          author={Flanagan, Dav and Thomas Segaran}
+        }
+        @misc{flanagan-2,
+          title={{Foo Bar}},
+          author={Flanagan, David and Matsumoto, Yukihiro}
+        }
+        END
+      end
+
+      describe '#entries_at' do
+        it 'returns a list of all entries identified by the passed-in keys' do
+          assert_equal [@bib['segaran2007'], @bib['rails']], @bib.entries_at('segaran2007', :rails)
+        end
+      end
+
+      describe '#extend_initials' do
+        it 'extends the initials in matching names' do
+          @bib.names.map(&:to_s).wont_include 'Flanagan, Dave'
+          @bib.extend_initials(['Dave', 'Flanagan'])
+          @bib.names.map(&:to_s).must_include 'Flanagan, Dave'
+        end
+      end
+
+      describe '#extend_initials!' do
+        it 'extends the initials of all names to the longest prototype' do
+          assert_equal "Ruby, Sam Thomas, Dave Hansson Heinemeier, David Flanagan, David Matsumoto, Yukihiro Segaran, Thomas",
+            @bib.extend_initials!.names.map(&:sort_order).uniq.join(' ')
+        end
+      end
+
+      describe '#unify' do
+        it 'sets all fields matching the given pattern to the passed-in value' do
+          @bib.unify :publisher, /reilly/i, 'OReilly'
+          assert_equal 'OReilly', @bib['segaran2007'].publisher
+          assert_equal 'OReilly', @bib['flanagan2008'].publisher
+        end
+
+        it 'does not change the value of fields that do not match' do
+          @bib.unify :publisher, /reilly/i, 'OReilly'
+          assert_equal 'The Pragmatic Bookshelf', @bib['rails'].publisher
+        end
+
+        it 'passes each entry with matching fields to the block if given' do
+          years = []
+          @bib.unify(:publisher, /reilly/i) { |e| years << e.year.to_s }
+          assert_equal ['2007','2008'], years.sort
+        end
+
+        it 'returns the bibliography' do
+          assert_equal @bib, @bib.unify(:publisher, /reilly/i, 'OReilly')
+        end
+      end
+
+      describe '#group_by' do
+        it 'returns an empy hash by default' do
+          assert_equal({}, Bibliography.new.group_by)
+          assert_equal({}, Bibliography.new.group_by(:a, :b))
+        end
+
+        it 'returns a hash with all the entries mapped to their default digest' do
+          assert_equal @bib.entries.length, @bib.group_by.length
+        end
+
+        it 'uses the given block to determine the key' do
+          assert_equal @bib.entries.length, (@bib.group_by { 'x' })['x'].length
+        end
+      end
+
+      it 'supports access by index' do
+        assert_equal 'ruby', @bib[1].keywords
+      end
+
+      it 'supports access by range' do
+        assert_equal %w{2008 2007}, @bib[1..2].map(&:year)
+      end
+
+      it 'supports access by index and offset' do
+        assert_equal %w{2008 2007}, @bib[1,2].map(&:year)
+      end
+
+      it 'supports queries by symbol key' do
+        refute_nil @bib[:rails]
+        assert_nil @bib[:ruby]
+      end
+
+      it 'supports queries by symbol key and selector' do
+        assert_equal 1, @bib.q(:all, :rails).length
+        refute_nil @bib.q(:first, :rails)
+        assert_nil @bib.q(:first, :railss)
+      end
+
+      it 'supports queries by string key' do
+        refute_nil @bib['rails']
+        assert_nil @bib['ruby']
+      end
+
+      it 'supports queries by type string' do
+        assert_equal 2, @bib['@book'].length
+        assert_equal 1, @bib['@article'].length
+        assert_equal 0, @bib['@collection'].length
+        assert_equal 1, @bib['@string'].length
+      end
+
+      it 'supports queries by negated type string' do
+        assert_equal 4, @bib['!@book'].length
+        assert_equal 5, @bib['!@article'].length
+        assert_equal 6, @bib['!@collection'].length
+        assert_equal 1, @bib['!@*'].length
+        assert_equal 4, @bib['!@misc'].length
+        assert_equal 5, @bib['!@string'].length
+      end
+
+      it 'supports queries by type string and selector' do
+        assert_equal 2, @bib.q(:all, '@book').length
+        refute_nil @bib.q(:first, '@book')
+        assert_equal 1, @bib.q(:all, '@article').length
+        refute_nil @bib.q(:first, '@article')
+        assert_equal 0, @bib.q(:all, '@collection').length
+        assert_nil @bib.q(:first, '@collection')
+      end
+
+
+      it 'supports queries by pattern' do
+        assert_equal 0, @bib[/reilly/].length
+        assert_equal 2, @bib[/reilly/i].length
+      end
+
+      it 'supports queries by type string and conditions' do
+        assert_equal 1, @bib['@book[keywords=ruby]'].length
+        assert_equal 1, @bib['@book[keywords = ruby]'].length
+        assert_equal 1, @bib['@book[ keywords = ruby]'].length
+        assert_equal 1, @bib['@book[keywords=ruby ]'].length
+        assert_equal 1, @bib['@*[type=interview]'].length
+      end
+
+      it 'supports queries with negative conditions' do
+        assert_equal 4, @bib['@*[keywords!=ruby]'].length
+      end
+
+      it 'supports queries with pattern conditions' do
+        assert_equal 1, @bib['@*[keywords~=rails]'].length
+      end
+
+      it 'supports queries with attribute conditions' do
+        assert_equal 2, @bib['@*[keywords]'].length
+        assert_equal 0, @bib['@*[foobar]'].length
+      end
+
+      it 'supports queries with start-pattern conditions' do
+        assert_equal 2, @bib['@*[keywords^=ruby]'].length
+      end
+
+      it 'supports queries with numeric conditions' do
+        assert_equal 3, @bib['@*[year<=2010]'].length
+        assert_equal 3, @bib['@*[year<=2009]'].length
+        assert_equal 2, @bib['@*[year>=2008]'].length
+        assert_equal 0, @bib['@*[year>=2010]'].length
+      end
+
+
+      it 'supports queries by bibtex element' do
+        entry = Entry.parse(<<-END).first
+        @article{segaran2007,
+          title = {{Programming collective intelligence}},
+          author = {Segaran, T.},
+          year = {2007},
+          publisher = {O'Reilly},
+          type={interview}
+        }
+        END
+        assert_equal 1, @bib[entry].length
+        entry.year = '2006'
+        assert_equal 0, @bib[entry].length
+      end
+
+      it 'supports query and additional block' do
+        assert_equal 1, @bib.q('@book') { |e| e.keywords.split(/,/).length > 1 }.length
+      end
+
+      it 'supports saving the bibliography to a file' do
+        tmp = Tempfile.new('bibtex')
+        tmp.close
+        @bib.save_to(tmp.path)
+        assert_equal @bib.length, BibTeX.open(tmp.path).length
+      end
+
+      describe '#query' do
+
+        it 'returns all elements when passed no arguments' do
+          @bib.query.length.must_be :==, 6
+        end
+
+        it 'returns all elements when passed :all and an empty condition' do
+          @bib.query(:all, '').length.must_be :==, 6
+        end
+
+        it 'returns all entries when passed a * wildcard' do
+          @bib.query('@*').length.must_be :==, 5
+        end
+
+      end
+
+      describe 'duplicates' do
+
+        it 'understands select_duplicates_by' do
+          assert_equal 1, @bib.select_duplicates_by.length
+        end
+
+        it 'understands duplicates?' do
+          assert @bib.duplicates?
+        end
+
+      end
+
+      describe '#uniq!' do
+        before do
+          @a = BibTeX.parse <<-END
+            @book{b1,
+              title = {FOO},
+              year = {2013},
+              author = {Doe, John},
+              pages = {1-2}}
+            @book{b2,
+              title = {BAR},
+              year = {2013},
+              author = {Doe, John},
+              pages = {1-3},
+              }
+          END
+          @b = BibTeX.parse <<-END
+            @book{b3,
+              title = {FOO},
+              year = {2013},
+              author = {Doe, John},
+              pages = {1-2}}
+          END
+        end
+
+        it 'returns the bibliography unchanged if there are no duplicates' do
+          assert @a.length == @a.uniq!.length
+          assert @b.length == @b.uniq!.length
+        end
+
+        it 'removes duplicate entries and returns the bibliography' do
+          assert @a.length > @a.uniq!(:author).length
+        end
+
+        describe 'with block' do
+          it 'removes duplicate entries and returns the bibliography' do
+            assert @a.length > @a.uniq!(:author){|d,e| d+'|'+e.pages_from}.length
+          end
+        end
+      end
+
+      describe 'given a filter' do
+        before do
+          @filter = Object.new
+          def @filter.apply (value); value.is_a?(::String) ? value.upcase : value; end
+        end
+
+        it 'supports arbitrary conversions' do
+          @bib.convert(@filter)
+          assert_equal 'RUBY, RAILS', @bib[:rails].keywords
+        end
+
+        it 'supports conditional arbitrary conversions' do
+          @bib.convert(@filter) { |e| e.key != 'rails' }
+          assert_equal 'ruby, rails', @bib[:rails].keywords
+          assert_equal 'RUBY', @bib[:flanagan2008].keywords
+        end
+
+      end
+
+      describe 'sorting' do
+
+        before do
+          @small_bib = BibTeX.parse <<-END
+        @book{flanagan2008,
+          title={{The ruby programming language}},
+          author={Flanagan, D. and Matsumoto, Y.},
+          keywords = {ruby},
+          year={2008},
+          publisher={O'Reilly}
+        }
+        @book{rails,
+          address = {Raleigh, North Carolina},
+          author = {Ruby, Sam, and Thomas, Dave, and Hansson Heinemeier, David},
+          booktitle = {Agile Web Development with Rails},
+          edition = {third},
+          keywords = {ruby, rails},
+          publisher = {The Pragmatic Bookshelf},
+          series = {The Facets of Ruby},
+          title = {Agile Web Development with Rails},
+          year = {2009}
+        }
+        @article{segaran2007,
+          title={{Programming collective intelligence}},
+          author={Segaran, T.},
+          year={2007},
+          publisher={O'Reilly}
+        }
+        END
+      end
+
+        it 'can be sorted destructively' do
+          @small_bib.sort!
+          @small_bib.map(&:key).must_equal [ 'segaran2007', 'flanagan2008', 'rails']
+        end
+
+        it 'can be sorted by field destructively' do
+          @small_bib.sort_by! { |e| -e[:year].to_i }
+          @small_bib.map(&:key).must_equal [  'rails', 'flanagan2008', 'segaran2007' ]
+        end
+
+        it 'can be sorted non-destructively' do
+          sorted_entries = @small_bib.sort
+          sorted_entries.map(&:key).must_equal [ 'segaran2007', 'flanagan2008', 'rails']
+          @small_bib.map(&:key).must_equal [  'flanagan2008', 'rails', 'segaran2007']
+        end
+
+        it 'can be sorted by field non-destructively' do
+          sorted_entries = @small_bib.sort_by { |e| -e[:year].to_i }
+          sorted_entries.map(&:key).must_equal [  'rails', 'flanagan2008', 'segaran2007' ]
+          @small_bib.map(&:key).must_equal [  'flanagan2008', 'rails', 'segaran2007']
+        end
+      end
+
+      describe 'LaTeX filter' do
+        before do
+          @bib['rails'].keywords = 'r\\"uby'
+        end
+
+        it 'converts LaTeX umlauts' do
+          @bib.convert(:latex)['rails'].keywords.must_be :==, 'rüby'
+        end
+
+      end
+
+      describe 'BibTeXML export' do
+        before { @bibtexml = Tempfile.new('bibtexml') }
+        after  { @bibtexml.unlink }
+
+        it 'supports exporting to BibTeXML' do
+          @bib.to_xml.write(@bibtexml, 2)
+          @bibtexml.rewind
+          xml = REXML::Document.new(@bibtexml)
+          xml.root.namespace.must_be :==, 'http://bibtexml.sf.net/'
+          xml.root.get_elements('//bibtex:entry').wont_be_empty
+        end
+
+        it 'supports exporting to extended BibTeXML' do
+          @bib.to_xml(:extended => true).write(@bibtexml, 2)
+          @bibtexml.rewind
+          xml = REXML::Document.new(@bibtexml)
+          xml.root.namespace.must_be :==, 'http://bibtexml.sf.net/'
+          xml.root.get_elements('//bibtex:person').wont_be_empty
+        end
+
+      end
+    end
+
+    describe '#add' do
+      before do
+        @bib = Bibliography.new(allow_missing_keys: true)
+      end
+
+      it 'should respect options provided to initializer' do
+        assert_equal(@bib.add('@article{, title = test}'), @bib)
+        assert(! @bib.entries.keys.any?(&:empty?))
+      end
+    end
+  end
+end