bibtex_to_scrapbox 0.1.0

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

@@ -0,0 +1,36 @@
+require 'helper.rb'
+
+module BibTeX
+  class FiltersTest < Minitest::Spec
+
+    it "should Filters should be singleton classes" do
+      assert_equal false, Filter.respond_to?(:new)
+      assert_equal Filter.instance.object_id, Filter.instance.object_id
+    end
+
+    describe 'Filters.resolve' do
+      it "should return the filter if a filter is given" do
+        assert_equal Filter.instance.object_id, Filters.resolve(Filter.instance).object_id
+      end
+
+      it "should return the parameter if it quacks like a filter" do
+        f = Object.new
+        def f.apply; nil; end
+        assert_equal f.object_id, Filters.resolve(f).object_id
+      end
+
+      it "should return the filter if there is a filter by that name" do
+        class FooBar < Filter; end
+        assert_equal FooBar.instance.object_id, Filters.resolve(:foobar).object_id
+        assert_equal FooBar.instance.object_id, Filters.resolve('foobar').object_id
+        Filter.subclasses.delete(FooBar)
+      end
+
+      it "should return nil if there is no filter by that name" do
+        assert_equal nil, Filters.resolve(:foobar)
+        assert_equal nil, Filters.resolve('foobar')
+        assert_equal nil, Filters.resolve(nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require 'helper.rb'
+
+module BibTeX
+  class LexerTest < Minitest::Spec
+
+    it 'correctly scans a string literal' do
+      assert_equal Lexer.new.analyse(%q(@string{ x = "foo" })).symbols, [:AT,:STRING,:LBRACE,:NAME,:EQ,:STRING_LITERAL,:RBRACE,false]
+    end
+
+    it 'strips line breaks by default' do
+      Lexer.new.analyse(%Q(@string{ x = "foo\nbar" })).stack[-3].must_be :==,
+        [:STRING_LITERAL, 'foo bar']
+    end
+
+    it 'strips whitespace after line breaks by default' do
+      Lexer.new.analyse(%Q(@string{ x = "foo\n    bar" })).stack[-3].must_be :==,
+        [:STRING_LITERAL, 'foo bar']
+    end
+
+    it 'matches KEY tokens' do
+      Lexer.new.analyse("@misc{foo, }").symbols.must_be :==, [:AT, :NAME, :LBRACE, :KEY, :RBRACE, false]
+    end
+
+    it 'matches KEY tokens with non-ascii characters' do
+      Lexer.new.analyse("@misc{löwe, }").symbols.must_be :==, [:AT, :NAME, :LBRACE, :KEY, :RBRACE, false]
+    end
+
+    it 'matches KEY tokens after whitespace' do
+      Lexer.new.analyse("@misc{  foo, }").symbols.must_be :==, [:AT, :NAME, :LBRACE, :KEY, :RBRACE, false]
+    end
+
+    it "doesn't start a comment for types starting with but not equal @comment" do
+      Lexer.new.analyse("@commentary{staudinger, }").symbols.must_be :==, [:AT, :NAME, :LBRACE, :KEY, :RBRACE, false]
+    end
+
+    it "doesn't start a preamble for types starting with but not equal @preamble" do
+      Lexer.new.analyse("@preamblestring{ preamble }").symbols.must_be :==, [:AT, :NAME, :LBRACE, :NAME, :RBRACE, false]
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'helper'
+
+module BibTeX
+  class NameParserTest < Minitest::Spec
+
+    describe "parse a number of entries having a 'van' or 'van den' name prefix" do
+      before do
+        @a = Names.parse('van den Bout, D. E.')
+        @b = Names.parse('Van den Bout, D. E.')
+      end
+
+      it "should parse 'van den' part starting with lowercase letter" do
+        assert_equal(@a[0].to_s, "van den Bout, D. E.")
+        assert_equal(@a[0].prefix, "van den")
+      end
+
+      it "should parse 'Van den' part starting with uppercase letter" do
+        assert_equal(@b[0].to_s, "Van den Bout, D. E.")
+        assert_equal(@b[0].prefix, "Van den")
+      end
+
+      it "should accept empty strings" do
+        assert_equal '', Names.parse("").to_s
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,168 @@
+# coding: utf-8
+
+require 'helper'
+
+module BibTeX
+  class NamesTest < Minitest::Spec
+
+    before do
+      @poe = Name.new(:first => 'Edgar Allen', :last => 'Poe')
+    end
+
+    describe 'string behaviour' do
+      before do
+        @name = Name.new(:first => 'Charles Louis Xavier Joseph', :prefix => 'de la', :last => 'Vallee Poussin', :suffix => 'Jr.')
+      end
+      it 'should implement upcase!' do
+        assert_equal 'DE LA VALLEE POUSSIN, JR., CHARLES LOUIS XAVIER JOSEPH', @name.upcase!.to_s
+      end
+      it 'should implement downcase!' do
+        assert_equal 'de la vallee poussin, jr., charles louis xavier joseph', @name.downcase!.to_s
+      end
+      it 'should implement gsub!' do
+        assert_equal 'dX la VallXX PoussXn, Jr., CharlXs LouXs XavXXr JosXph', @name.gsub!(/[ei]/, 'X').to_s
+      end
+    end
+
+    describe '#display_order' do
+      it 'returns the name as "first last"' do
+        @poe.display_order.must_be :==, 'Edgar Allen Poe'
+      end
+
+      it 'accepts the :initials option' do
+        @poe.display_order(:initials => true).must_be :==, 'E.A. Poe'
+      end
+    end
+
+    describe '#sort_order' do
+      it 'returns the name as "last, first"' do
+        @poe.sort_order.must_be :==, 'Poe, Edgar Allen'
+      end
+
+      it 'accepts the :initials option' do
+        @poe.sort_order(:initials => true).must_be :==, 'Poe, E.A.'
+      end
+    end
+
+    describe '#initials?' do
+      it 'returns true if the name contains a solely initials as a first name' do
+        @poe.initials?.must_equal false
+
+        @poe.first = 'Edgar A.'
+        @poe.initials?.must_equal false
+
+        @poe.first = 'E.A.'
+        @poe.initials?.must_equal true
+
+        @poe.first = ''
+        @poe.initials?.must_equal false
+
+        @poe.first = nil
+        @poe.initials?.must_equal false
+      end
+    end
+
+    describe '#rename_if' do
+      it 'renames the name to the given attributes if no condition is given' do
+        @poe.rename_if({ :first => 'E.A.' }).first.must_equal 'E.A.'
+      end
+
+      it 'renames the name to the given attributes if all conditions match' do
+        @poe.rename_if({ :first => 'E.A.' }, { :last => @poe.last }).first.must_equal 'E.A.'
+        @poe.rename_if({ :first => 'E.A.' }, { :last => @poe.last, :first => @poe.first }).first.must_equal 'E.A.'
+      end
+
+      it 'renames the name to the given attributes if the block returns true' do
+        @poe.rename_if({ :first => 'E.A.' }) {|n| true}.first.must_equal 'E.A.'
+      end
+
+      it 'does not rename the name to the given attributes if at least one condition does not match' do
+        @poe.rename_if({ :first => 'E.A.' }, { :last => 'foo' }).first.wont_equal 'E.A.'
+        @poe.rename_if({ :first => 'E.A.' }, { :last => 'foo', :first => @poe.first }).first.wont_equal 'E.A.'
+        @poe.rename_if({ :first => 'E.A.' }, { :last => @poe.last, :first => 'foo' }).first.wont_equal 'E.A.'
+      end
+
+      it 'does not rename the name to the given attributes if the block returns false' do
+        @poe.rename_if({ :first => 'E.A.' }) {|n| false}.first.wont_equal 'E.A.'
+      end
+    end
+
+    describe '#merge!' do
+      it 'does not merge duplicates' do
+        n1 = Names.new(@poe)
+        n2 = Names.new(@poe)
+        assert_equal @poe.to_s, n1.merge!(n2).to_s
+      end
+
+      it 'merges different names' do
+        n1 = Names.new(@poe)
+        n2 = Names.new(Name.new(:last => 'Plato'))
+        assert_equal "#{@poe.to_s} and Plato", n1.merge!(n2).to_s
+      end
+    end
+
+    describe '#normalize_initials' do
+      it 'returns normalized initials of existing initials only' do
+        Name.new(:first => 'Edgar A.', :last => 'Poe').normalize_initials.must_equal 'Edgar A.'
+        Name.new(:first => 'E.A.', :last => 'Poe').normalize_initials.must_equal 'E.A.'
+        Name.new(:first => 'E. A.', :last => 'Poe').normalize_initials.must_equal 'E.A.'
+        Name.new(:first => 'E. A', :last => 'Poe').normalize_initials.must_equal 'E.A.'
+        Name.new(:first => 'E A', :last => 'Poe').normalize_initials.must_equal 'E.A.'
+        Name.new(:first => 'Edgar A P', :last => 'Poe').normalize_initials.must_equal 'Edgar A.P.'
+      end
+    end
+
+    describe '#extend_initials' do
+      it 'extends the first name if the last name and initials match' do
+        Name.new(:first => 'E.A.', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'Edgar A.', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E. A.', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E. A', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E A', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E. Allen', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E.A.', :last => 'Poe').extend_initials('Edgar A.', 'Poe').first.must_equal 'Edgar A.'
+
+        Name.new(:first => 'Edgar-A.', :last => 'Poe').extend_initials('Edgar-Allen', 'Poe').first.must_equal 'Edgar-Allen'
+        Name.new(:first => 'E.-Allen', :last => 'Poe').extend_initials('Edgar-Allen', 'Poe').first.must_equal 'Edgar-Allen'
+        Name.new(:first => 'E.-A.', :last => 'Poe').extend_initials('Edgar-Allen', 'Poe').first.must_equal 'Edgar-Allen'
+        Name.new(:first => 'E.-A', :last => 'Poe').extend_initials('Edgar-Allen', 'Poe').first.must_equal 'Edgar-Allen'
+        Name.new(:first => 'E-A', :last => 'Poe').extend_initials('Edgar-Allen', 'Poe').first.must_equal 'Edgar-Allen'
+      end
+
+      it 'extends the first name if the last name and initials name match with extra middle names' do
+        Name.new(:first => 'E.', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'E', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+        Name.new(:first => 'Edgar', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.must_equal 'Edgar Allen'
+
+        Name.new(:first => 'E.A.', :last => 'Poe').extend_initials('Edgar', 'Poe').first.must_equal 'E.A.'
+        Name.new(:first => 'A.', :last => 'Poe').extend_initials('Edgar', 'Poe').first.must_equal 'A.'
+      end
+
+      it 'does not extend the first name if the last name or initials do not match' do
+        Name.new(:first => 'E.A.', :last => 'Poe').extend_initials('Edgar Allen', 'Poser').first.wont_equal 'Edgar Allen'
+        Name.new(:first => 'E.A.', :last => 'Poe').extend_initials('Edgar Ellen', 'Poe').first.wont_equal 'Edgar Ellen'
+        Name.new(:first => 'E.R.', :last => 'Poe').extend_initials('Edgar Allen', 'Poe').first.wont_equal 'Edgar Allen'
+      end
+    end
+
+		describe "conversions" do
+      class UpcaseAll < BibTeX::Filter
+        def apply (value)
+          value.upcase
+        end
+      end
+
+      describe "#convert" do
+        it "converts the value when given a filter instance" do
+					Names.parse('Poe and Hawthorne').convert(UpcaseAll.instance).to_s.must_be :==, 'POE and HAWTHORNE'
+        end
+
+				it "converts LaTeX umlauts" do
+					Names.parse("S{\\o}ren Kirkegaard and Emmanuel L\\'evinas").convert(:latex).to_s.must_be :==, 'Kirkegaard, Søren and Lévinas, Emmanuel'
+				end
+			end
+		end
+
+  end
+
+end

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

@@ -0,0 +1,210 @@
+require 'helper.rb'
+
+module BibTeX
+  class ParserTest < Minitest::Spec
+
+    describe 'given a set of valid @entries' do
+      before do
+        @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:entry)))
+      end
+
+      it 'returns a Bibliography instance' do
+        assert @bib
+        refute @bib.empty?
+      end
+
+      it 'parses all entries' do
+        assert_equal 4, @bib.length
+      end
+
+      it 'parses the key values' do
+        assert_equal %w{ key:0 key:1 foo staudinger }, @bib.map(&:key)
+      end
+
+      it 'should parse the entry types' do
+        assert_equal [:book, :article, :article, :commentary], @bib.map(&:type)
+      end
+
+      it 'should parse all values correctly' do
+        assert_equal 'Poe, Edgar A.', @bib[:'key:0'].author.to_s
+        assert_equal 'Hawthorne, Nathaniel', @bib[:'key:1'].author.to_s
+
+        assert_equal '2003', @bib[:'key:0'].year
+        assert_equal '2001', @bib[:'key:1'].year
+
+        assert_equal 'American Library', @bib[:'key:0'].publisher
+        assert_equal 'American Library', @bib[:'key:1'].publisher
+
+        assert_equal %q[Selected \emph{Poetry} and `Tales'], @bib[:'key:0'].title
+        assert_equal 'Tales and Sketches', @bib[:'key:1'].title
+      end
+    end
+
+    describe 'key parsing' do
+      it 'handles whitespace in keys' do
+        input = "@Misc{George Martin06,title = {FEAST FOR CROWS}}"
+        bib = Parser.new(:debug => false, :strict => false).parse(input)
+        assert_equal "George Martin06", bib.first.key
+        assert bib[:"George Martin06"]
+      end
+
+      it 'handles plus symbols in keys' do
+        input = "@Misc{foo+bar,title = {Foobar}}"
+        bib = Parser.new(:debug => false, :strict => false).parse(input)
+        assert_equal "foo+bar", bib.first.key
+        assert bib[:"foo+bar"]
+      end
+
+      it 'allows semicolons in keys' do
+        input = "@Misc{Gomez;,title = {Foobar}}"
+        bib = Parser.new(:debug => false, :strict => false).parse(input)
+        assert_equal "Gomez;", bib.first.key
+        assert bib[:"Gomez;"]
+      end
+
+      it 'fails when there is no cite-key' do
+        input = "@misc{title = {Crime and Punishment}}"
+        assert_raises ParseError do
+          Parser.new(:debug => false, :strict => false).parse(input)
+        end
+      end
+
+      it 'tolerates missing key with :allow_missing_keys set' do
+        input = "@misc{title = {Crime and Punishment}}"
+        assert_equal :misc, Parser.new({
+          :debug => false, :strict => false, :allow_missing_keys => true
+        }).parse(input)[0].type
+      end
+    end
+
+    describe 'backslashes and escape sequences' do
+
+      it 'leaves backslashes intact' do
+        Parser.new.parse(%q(@misc{key, title = "a backslash: \"}))[0].title.must_be :==, 'a backslash: \\'
+      end
+
+      it 'parses LaTeX escaped quotes {"}' do
+        Parser.new.parse(%q(@misc{key, title = "{"}"}))[0].title.must_be :==, '{"}'
+      end
+
+      it 'parses complex LaTeX markup' do
+        b = Parser.new.parse(<<-END)[0]
+          @book{proust_1996,
+            address = {Paris},
+            author = {Proust, Jo\\"{e}lle},
+            booktitle = {Perception et Intermodalit\\'{e}: Approches Actuelles De La Question De Molyneux},
+            editor = {Proust, Jo\\"{e}lle},
+            keywords = {Perception; Molyneux's Problem},
+            publisher = {Presses Universitaires de France},
+            title = {Perception et Intermodalit\\'{e}: Approches Actuelles De La Question De Molyneux},
+            year = {1996}
+          }
+        END
+        b.booktitle.must_be :==, "Perception et Intermodalit\\'{e}: Approches Actuelles De La Question De Molyneux"
+        b.editor.to_s.must_be :==, 'Proust, Jo\"{e}lle'
+      end
+
+    end
+
+    describe 'given a set of explicit and implicit comments' do
+      before do
+        @bib = Parser.new(:debug => false, :include => [:meta_content]).parse(File.read(Test.fixtures(:comment)))
+      end
+
+      it 'should parses all @comments' do
+        assert_equal 2, @bib.comments.length
+      end
+
+      it 'should parses all meta content' do
+        assert_equal 3, @bib.meta_contents.length
+      end
+
+      it 'should parse @comment content as string' do
+        assert_equal ' A comment can contain pretty much anything ', @bib.comments[0].content
+        assert_equal %Q[\n@string{ foo = "bar" }\n\n@string{ bar = "foo" }\n], @bib.comments[1].content
+      end
+    end
+
+    describe 'given a set of @preambles' do
+      before do
+        @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:preamble)))
+      end
+
+      it 'should parse all @preambles' do
+        assert_equal 3, @bib.preambles.length
+      end
+
+      it 'should parse all contents' do
+        assert_equal 'This bibliography was created \\today', @bib.preambles[0].value.to_s
+        assert_equal 'Bib\\TeX', @bib.preambles[1].value.to_s
+        assert_equal '"Maintained by " # maintainer', @bib.preambles[2].value.to_s
+      end
+    end
+
+    describe 'given an entry containing a multi-line literals' do
+      before do
+        @braces = %Q[@TechReport{key,\n  author = {Donald,\n     Duck}\n}]
+        @string = %Q[@TechReport{key,\n  author = "Donald,\n     Duck"\n}]
+      end
+
+      it 'should parse string literals' do
+        refute_nil Parser.new.parse(@string)[:key]
+      end
+
+      it 'should parse braced literals' do
+        refute_nil Parser.new.parse(@braces)[:key]
+      end
+
+    end
+
+    describe 'year values' do
+      it 'parses non-numeric year literals' do
+        assert_equal 'to appear',
+          Parser.new.parse("@article{x,  year = {to appear}}")['x'].year.to_s
+      end
+
+      it 'parses numeric year literals' do
+        assert_equal 1993,
+          Parser.new.parse("@article{x,  year = { 1993 }}")['x'].year.to_i
+      end
+    end
+
+    describe 'given an entry with missing commas between fields' do
+      before do
+        @level = BibTeX.log.level
+        BibTeX.log.level = Logger::FATAL
+      end
+
+      after do
+        BibTeX.log.level = @level
+      end
+
+      it 'raises a parser error' do
+        lambda {
+          Parser.new.parse <<-END
+            @book{book1,
+             title = "Parse error because"
+             author = "comma missing between title and author"
+            }
+          END
+        }.must_raise(ParseError)
+      end
+    end
+
+    describe 'given an entry with empty values' do
+      it 'does not raise an error' do
+        bib = BibTeX.parse <<-END
+          @Incollection{test,
+            author = {author},
+            title = {title},
+            editor = {},
+          }
+        END
+
+        assert_equal 'author', bib[:test][:author]
+        assert_equal 'title', bib[:test][:title]
+        assert_equal '', bib[:test][:editor]
+      end
+    end
+  end
+end