bibtex_to_scrapbox 0.2.0 → 0.2.1

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

@@ -1,36 +0,0 @@
-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

@@ -1,42 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-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

@@ -1,168 +0,0 @@
-# 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

@@ -1,210 +0,0 @@
-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