bibtex-ruby 1.2.1 → 1.3.0

data/test/bibtex/test_elements.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+module BibTeX
+  
+  class PreambleTest < MiniTest::Spec
+    
+    context 'a new preamble instance' do
+      setup do
+        @preamble = Preamble.new
+      end
+      
+      should 'not be nil' do
+        assert @preamble
+      end
+    end
+    
+    context 'given a set of @preambles' do
+      setup do
+        @bib = BibTeX.open(Test.fixtures(:preamble))
+        @preambles = @bib.preambles
+      end
+      
+      should 'support round-trips of all parsed preambles' do
+        assert_equal %q[@preamble{ "This bibliography was created \today" }], @preambles[0].to_s
+        assert_equal %q[@preamble{ "Bib\TeX" }], @preambles[1].to_s
+        assert_equal %q[@preamble{ "Maintained by " # maintainer }], @preambles[2].to_s
+      end
+
+      should 'support string replacement of preamble contents' do
+        assert_equal %q["Maintained by " # maintainer], @preambles[2].value.to_s
+        @bib.replace_strings
+        assert_equal %q["Maintained by " # "Myself"], @preambles[2].value.to_s
+        @bib.join_strings
+        assert_equal 'Maintained by Myself', @preambles[2].value.to_s
+      end
+    end
+
+  end
+  
+end

data/test/bibtex/test_entry.rb

@@ -0,0 +1,99 @@
+require 'helper.rb'
+
+module BibTeX
+  class EntryTest < MiniTest::Spec
+
+    context 'a new Entry' do
+      should 'not be nil' do
+        assert Entry.new
+      end
+    end
+
+    def test_simple
+      bib = BibTeX::Bibliography.open(Test.fixtures(:entry), :debug => false)
+      refute_nil(bib)
+      assert_equal(BibTeX::Bibliography, bib.class)
+      assert_equal(3, bib.data.length)
+      assert_equal([BibTeX::Entry], bib.data.map(&:class).uniq)
+      assert_equal(:'key:0', bib.data[0].key)
+      assert_equal(:'key:1', bib.data[1].key)
+      assert_equal(:'foo', bib.data[2].key)
+      assert_equal(:book, bib.data[0].type)
+      assert_equal(:article, bib.data[1].type)
+      assert_equal(:article, bib.data[2].type)
+      assert_equal('Poe, Edgar A.', bib.data[0][:author])
+      assert_equal('Hawthorne, Nathaniel', bib.data[1][:author])
+      assert_equal('2003', bib.data[0][:year])
+      assert_equal('2001', bib.data[1][:year])
+      assert_equal('American Library', bib.data[0][:publisher])
+      assert_equal('American Library', bib.data[1][:publisher])
+      assert_equal('Selected \\emph{Poetry} and `Tales\'', bib.data[0].title)
+      assert_equal('Tales and Sketches', bib.data[1].title)
+    end
+  
+    def test_ghost_methods
+      bib = BibTeX::Bibliography.open(Test.fixtures(:entry), :debug => false)
+
+      assert_equal 'Poe, Edgar A.', bib[0].author
+    
+      expected = 'Poe, Edgar Allen'
+      bib.data[0].author = expected
+    
+      assert_equal expected, bib[0].author
+    end
+  
+    def test_creation_simple
+      expected = "@book{raven,\n  author = {Poe, Edgar A.},\n  title = {The Raven}\n}\n"
+    
+      entry = BibTeX::Entry.new
+      entry.type = :book
+      entry.key = :raven
+      entry.author = 'Poe, Edgar A.'
+      entry.title = 'The Raven'
+    
+      assert_equal expected, entry.to_s
+    end
+
+    def test_creation_from_hash
+      expected = "@book{raven,\n  author = {Poe, Edgar A.},\n  title = {The Raven}\n}\n"
+    
+      entry = BibTeX::Entry.new({
+        :type => 'book',
+        :key => :raven,
+        :author => 'Poe, Edgar A.',
+        :title => 'The Raven'
+      })
+    
+      assert_equal expected, entry.to_s
+    end
+
+    def test_creation_from_block
+      expected = "@book{raven,\n  author = {Poe, Edgar A.},\n  title = {The Raven}\n}\n"
+    
+      entry = BibTeX::Entry.new do |e|
+        e.type = :book
+        e.key = :raven
+        e.author = 'Poe, Edgar A.'
+        e.title = 'The Raven'
+      end
+    
+      assert_equal expected, entry.to_s
+    end
+  
+    def test_sorting
+      entries = []
+      entries << BibTeX::Entry.new({ :type => 'book', :key => 'raven3', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << BibTeX::Entry.new({ :type => 'book', :key => 'raven2', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << BibTeX::Entry.new({ :type => 'book', :key => 'raven1', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << BibTeX::Entry.new({ :type => 'book', :key => 'raven1', :author => 'Poe, Edgar A.', :title => 'The Aven'})
+    
+      entries.sort!
+    
+      assert_equal [:raven1, :raven1, :raven2, :raven3], entries.map(&:key)
+      assert_equal ['The Aven', 'The Raven'], entries.map(&:title)[0,2]
+
+    end
+  
+  
+  end
+end

data/test/bibtex/test_names.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+module BibTeX
+  class NamesTest < MiniTest::Spec
+    
+    context 'string behaviour' do
+      setup do
+        @name = Name.new(:first => 'Charles Louis Xavier Joseph', :prefix => 'de la', :last => 'Vallee Poussin', :suffix => 'Jr.')
+      end
+      should 'implement upcase!' do
+        assert_equal 'DE LA VALLEE POUSSIN, JR., CHARLES LOUIS XAVIER JOSEPH', @name.upcase!.to_s
+      end
+      should 'implement downcase!' do
+        assert_equal 'de la vallee poussin, jr., charles louis xavier joseph', @name.downcase!.to_s
+      end
+      should 'implement gsub!' do
+        assert_equal 'dX la VallXX PoussXn, Jr., CharlXs LouXs XavXXr JosXph', @name.gsub!(/[ei]/, 'X').to_s        
+      end
+      
+    end
+    
+  end
+end

data/test/bibtex/test_parser.rb

@@ -0,0 +1,79 @@
+require 'helper.rb'
+
+module BibTeX
+  class ParserTest < MiniTest::Spec
+    
+    context 'given a set of valid @entries' do
+      setup do
+        @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:entry)))
+      end
+      
+      should 'return a Bibliography' do
+        assert @bib
+        refute @bib.empty?
+      end
+        
+      should 'parse all entries' do
+        assert_equal 3, @bib.length
+      end
+      
+      should 'parse the key values' do
+        assert_equal %w{ key:0 key:1 foo }.map(&:to_sym), @bib.map(&:key)
+      end
+
+      should 'parse the entry types' do
+        assert_equal [:book, :article, :article], @bib.map(&:type)
+      end
+      
+      should 'parse all values correctly' do
+        assert_equal 'Poe, Edgar A.', @bib[:'key:0'].author
+        assert_equal 'Hawthorne, Nathaniel', @bib[:'key:1'].author
+        
+        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
+    
+    context 'given a set of explicit and implicit comments' do
+      setup do
+        @bib = Parser.new(:debug => false, :include => [:meta_content]).parse(File.read(Test.fixtures(:comment)))
+      end
+      
+      should 'parses all @comments' do
+        assert_equal 2, @bib.comments.length
+      end
+
+      should 'parses all meta content' do
+        assert_equal 3, @bib.meta_contents.length
+      end
+      
+      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
+    
+    context 'given a set of @preambles' do
+      setup do
+        @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:preamble)))
+      end
+      
+      should 'parse all @preambles' do
+        assert_equal 3, @bib.preambles.length
+      end
+      
+      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
+    
+  end
+end

data/test/bibtex/test_string.rb

@@ -0,0 +1,83 @@
+require 'helper.rb'
+
+module BibTeX
+  class StringTest < MiniTest::Spec
+
+    context 'when parsing a simple string' do
+      setup do
+        @bib = BibTeX.parse('@string{ foo = "bar" }')
+      end        
+      should 'should not be empty' do
+        assert_equal 1, @bib.length
+      end
+      should 'have a symbol as key' do
+        assert_equal :foo, @bib[0].key
+      end
+      should 'have a value string' do
+        assert_equal 'bar', @bib[0].value.to_s
+      end
+      should 'have been registered' do
+        refute @bib.strings[:foo].nil?
+      end
+    end
+
+    # 
+    # def test_replacement
+    #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
+    #   refute_nil(bib)
+    #   assert(bib.kind_of?(BibTeX::Bibliography))
+    #   refute(bib.empty?)
+    #   assert_equal(7,bib.length)
+    #   assert_equal([BibTeX::String,BibTeX::Preamble,BibTeX::Entry], bib.data.map(&:class).uniq) 
+    #   assert_equal(["foo"], bib.strings[:foo])
+    #   assert_equal(["bar"], bib.strings[:bar])
+    #   assert_equal([:foo, "bar"], bib.strings[:foobar])
+    #   assert_equal([:foobar, :foo], bib.strings[:foobarfoo])
+    #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # foo # foobarfoo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:preamble]})
+    #   assert_equal(["foo"], bib.strings[:foo])
+    #   assert_equal(["bar"], bib.strings[:bar])
+    #   assert_equal([:foo, "bar"], bib.strings[:foobar])
+    #   assert_equal([:foobar, :foo], bib.strings[:foobarfoo])
+    #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:string]})
+    #   assert_equal(['foo','bar'], bib.strings[:foobar])
+    #   assert_equal(['foo', 'bar','foo'], bib.strings[:foobarfoo])
+    #   assert_equal(['bar','foo','bar'], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:preamble,:entry]})
+    #   assert_equal('"foo" # "foo" # "foo" # "bar" # "foo" # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # "bar" # "foo" # "bar"', bib[:'manual:1'].title)
+    # end
+    #   
+    # def test_roundtrip
+    #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
+    #   refute_nil(bib)
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = foo # "bar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = foobar # foo }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = bar # "foo" # bar }', bib.data[4].to_s)
+    #   bib.replace_strings
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = "foo" # "bar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = "foo" # "bar" # "foo" }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = "bar" # "foo" # "bar" }', bib.data[4].to_s)
+    #   bib.join_strings
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = "foobar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = "foobarfoo" }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = "barfoobar" }', bib.data[4].to_s)
+    # end
+  end
+end

data/test/bibtex/test_utilities.rb

@@ -0,0 +1,34 @@
+require 'helper.rb'
+
+module BibTeX
+  
+  class TestBibtex < MiniTest::Unit::TestCase
+        
+    def test_empty?
+      assert BibTeX.open(Test.fixtures(:empty)).empty?
+      refute BibTeX.open(Test.fixtures(:bibdesk)).empty?
+    end
+  
+    def test_parse
+      bib = BibTeX.parse %q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia" } ]
+      assert_equal 1, bib.length
+      assert_equal 'Ligeia', bib[:id].title
+      assert_equal 'Poe, Edgar Allen', bib[:id].author
+    end
+      
+    def test_validation
+      log_level = BibTeX.log.level
+      BibTeX.log.level = Logger::ERROR
+      
+      refute BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia" } ]).valid?
+      assert BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      assert BibTeX.parse(%q[ @book{ id, editor = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      refute BibTeX.parse(%q[ @book{ id, xxxxxx = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      refute BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Lig"eia", publisher = "Penguin", year = 1996 } ]).valid?
+      assert BibTeX.valid?(Test.fixtures(:bibdesk))
+      
+      BibTeX.log.level = log_level
+    end
+  end
+  
+end

data/test/bibtex/test_value.rb

@@ -0,0 +1,70 @@
+require 'helper.rb'
+
+module BibTeX
+  class ValueTest < MiniTest::Spec
+    
+    context "when empty" do
+      should "be equal to an empty string" do
+        assert Value.new == ''
+        assert Value.new('') == ''
+      end
+      should "be empty" do
+        assert Value.new.empty?
+        assert Value.new('').empty?
+      end
+      should "match an empty pattern" do
+        assert Value.new =~ //
+        assert Value.new('') =~ //
+      end
+    end
+    
+    context "#join" do
+      should "return empty string when empty" do
+        assert_equal '', Value.new.join.to_s
+        assert_equal '', Value.new('').join.to_s
+      end
+      should "return the string if atomic" do
+        assert_equal 'foo', Value.new('foo').join.to_s
+      end
+      should "return a string concatenation of all strings when containing only strings" do
+        assert_equal 'foobar', Value.new('foo', 'bar').join.to_s
+        assert_equal 'foobar', Value.new(['foo', 'bar']).join.to_s
+      end
+      should "should be atomic after join when containing only strings" do
+        refute Value.new('foo', 'bar').atomic?
+        assert Value.new('foo', 'bar').join.atomic?
+      end
+      should "do nothing when containing only symbols" do
+        value = Value.new(:foo)
+        assert_equal value, value.join
+        value = Value.new(:foo, :bar)
+        assert_equal value, value.join
+      end
+      should "do nothing when containing only symbols and a single string" do
+        value = Value.new(:foo, 'bar')
+        assert_equal value, value.join
+        value = Value.new('foo', :bar)
+        assert_equal value, value.join
+      end
+    end
+  
+    context "#to_s" do
+      should "return the string if atomic" do
+        assert_equal 'foo bar', Value.new('foo bar').to_s
+      end
+      should "return the symbol as string when containing only a single symbol" do
+        assert_equal 'foo', Value.new(:foo).to_s
+      end
+      should "return all string tokens concatenated by #" do
+        assert_equal '"foo" # "bar"', Value.new('foo', 'bar').to_s
+      end
+      should "return all symbol tokens concatenated by #" do
+        assert_equal 'foo # bar', Value.new(:foo, :bar).to_s
+      end
+      should "return all symbol and string tokens concatenated by #" do
+        assert_equal 'foo # "bar"', Value.new(:foo, 'bar').to_s
+        assert_equal '"foo" # bar', Value.new('foo', :bar).to_s
+      end
+    end
+  end
+end

data/test/{bib/10_bibdesk.bib → fixtures/bibdesk.bib}

@@ -11,7 +11,7 @@
 
 @book{rails,
 	Address = {Raleigh, North Carolina},
-	Author = {Ruby, Sam, and Thomas, Dave, and Hansson, David Heinemeier},
+	Author = {Ruby, Sam, and Thomas, Dave, and Hansson Heinemeier, David},
 	Booktitle = {Agile Web Development with Rails},
 	Date-Added = {2010-08-05 10:01:36 +0200},
 	Date-Modified = {2010-08-05 10:06:46 +0200},