bibtex-ruby 1.3.12 → 2.0.0pre1

data/test/bibtex/test_filters.rb

@@ -3,30 +3,30 @@ require 'helper.rb'
 module BibTeX
   class FiltersTest < MiniTest::Spec
     
-    should "Filters should be singleton classes" do
+    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
     
-    context 'Filters.resolve' do
-      should "return the filter if a filter is given" do
+    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
 
-      should "return the parameter if it quacks like a filter" do
+      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
 
-      should "return the filter if there is a filter by that name" do
+      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
       
-      should "return nil if there is no filter by that name" do
+      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)

data/test/bibtex/test_lexer.rb

@@ -3,7 +3,7 @@ require 'helper.rb'
 module BibTeX
   class LexerTest < MiniTest::Spec
 
-    should 'correctly scan a string literal' do
+    it 'should correctly scan a string literal' do
       assert_equal Lexer.new.analyse(%q(@string{ x = "foo" })).symbols, [:AT,:STRING,:LBRACE,:NAME,:EQ,:STRING_LITERAL,:RBRACE,false]
     end
  

data/test/bibtex/test_name_parser.rb

@@ -3,18 +3,18 @@ require 'helper'
 module BibTeX
   class NameParserTest < MiniTest::Spec
 
-    context "parse a number of entries having a 'van' or 'van den' name prefix" do
-      setup do
+    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
 
-      should "parse 'van den' part starting with lowercase letter" do
+      it "should parse 'van den' part starting with lowercase letter" do
         assert_equal(@a[0].to_str, "van den Bout, D. E.")
         assert_equal(@a[0].prefix, "van den")
       end
 
-      should "parse 'Van den' part starting with uppercase letter" do
+      it "should parse 'Van den' part starting with uppercase letter" do
         assert_equal(@b[0].to_str, "Van den Bout, D. E.")
         assert_equal(@b[0].prefix, "Van den")
       end

data/test/bibtex/test_names.rb

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

data/test/bibtex/test_parser.rb

@@ -3,36 +3,36 @@ require 'helper.rb'
 module BibTeX
   class ParserTest < MiniTest::Spec
     
-    context 'given a set of valid @entries' do
-      setup do
+    describe 'given a set of valid @entries' do
+      before do
         @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:entry)))
       end
       
-      should 'return a Bibliography' do
+      it 'should return a Bibliography' do
         assert @bib
         refute @bib.empty?
       end
         
-      should 'parse all entries' do
+      it '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)
+      it 'should parse the key values' do
+        assert_equal %w{ key:0 key:1 foo }, @bib.map(&:key)
       end
 
-      should 'handle strange keys' do
+      it 'should handle strange 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_equal "George Martin06", bib.first.key
         assert bib[:"George Martin06"]
       end
 
-      should 'parse the entry types' do
+      it 'should parse the entry types' do
         assert_equal [:book, :article, :article], @bib.map(&:type)
       end
       
-      should 'parse all values correctly' do
+      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
         
@@ -47,52 +47,52 @@ module BibTeX
       end     
     end
     
-    context 'given a set of explicit and implicit comments' do
-      setup do
+    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
       
-      should 'parses all @comments' do
+      it 'should parses all @comments' do
         assert_equal 2, @bib.comments.length
       end
 
-      should 'parses all meta content' do
+      it 'should parses all meta content' do
         assert_equal 3, @bib.meta_contents.length
       end
       
-      should 'parse @comment content as string' do
+      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
     
-    context 'given a set of @preambles' do
-      setup do
+    describe 'given a set of @preambles' do
+      before do
         @bib = Parser.new(:debug => false).parse(File.read(Test.fixtures(:preamble)))
       end
       
-      should 'parse all @preambles' do
+      it 'should parse all @preambles' do
         assert_equal 3, @bib.preambles.length
       end
       
-      should 'parse all contents' do
+      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
     
-    context 'given an entry containing a multi-line literals' do
-      setup do
+    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
       
-      should 'parse string literals' do
+      it 'should parse string literals' do
         refute_nil Parser.new.parse(@string)[:key]
       end
 
-      should 'parse braced literals' do
+      it 'should parse braced literals' do
         refute_nil Parser.new.parse(@braces)[:key]
       end
 

data/test/bibtex/test_string.rb

@@ -3,20 +3,20 @@ require 'helper.rb'
 module BibTeX
   class StringTest < MiniTest::Spec
 
-    context 'when parsing a simple string' do
-      setup do
+    describe 'when parsing a simple string' do
+      before do
         @bib = BibTeX.parse('@string{ foo = "bar" }')
       end        
-      should 'should not be empty' do
+      it 'should should not be empty' do
         assert_equal 1, @bib.length
       end
-      should 'have a symbol as key' do
+      it 'should have a symbol as key' do
         assert_equal :foo, @bib[0].key
       end
-      should 'have a value string' do
+      it 'should have a value string' do
         assert_equal 'bar', @bib[0].value.to_s
       end
-      should 'have been registered' do
+      it 'should have been registered' do
         refute @bib.strings[:foo].nil?
       end
     end

data/test/bibtex/test_value.rb

@@ -3,44 +3,44 @@ require 'helper.rb'
 module BibTeX
   class ValueTest < MiniTest::Spec
     
-    context "when empty" do
-      should "be equal to an empty string" do
+    describe "when empty" do
+      it "should be equal to an empty string" do
         assert Value.new == ''
         assert Value.new('') == ''
       end
-      should "be empty" do
+      it "should be empty" do
         assert Value.new.empty?
         assert Value.new('').empty?
       end
-      should "match an empty pattern" do
+      it "should match an empty pattern" do
         assert Value.new =~ //
         assert Value.new('') =~ //
       end
     end
     
-    context "#join" do
-      should "return empty string when empty" do
+    describe "#join" do
+      it "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
+      it "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
+      it "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
+      it "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
+      it "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
+      it "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)
@@ -48,27 +48,27 @@ module BibTeX
       end
     end
   
-    context "#to_s" do
-      should "return the string if atomic" do
+    describe "#to_s" do
+      it "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
+      it "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
+      it "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
+      it "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
+      it "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
     
-    context "conversions" do
-      setup do
+    describe "conversions" do
+      before do
         class Upcase < BibTeX::Filter
           def apply (value)
             value.is_a?(::String) ? value.upcase : value
@@ -77,54 +77,54 @@ module BibTeX
         @values = [Value.new('foo'), Value.new('foo', :bar)]
       end
       
-      context "#convert" do
-        should "convert the value when given a filter instance" do
+      describe "#convert" do
+        it "should convert the value when given a filter instance" do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase.instance).to_s }
         end
 
-        should "convert the value when given a filter class" do
+        it "should convert the value when given a filter class" do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase).to_s }
         end
 
-        should "convert the value when given the name of a filter" do
+        it "should convert the value when given the name of a filter" do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(:upcase).to_s }
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert('upcase').to_s }
         end
 
-        should "convert the value when using a ghost method" do
+        it "should convert the value when using a ghost method" do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert_upcase.to_s }
         end
         
-        should "not alter the value when using a filter name" do
+        it "should not alter the value when using a filter name" do
           @values.each { |v| v.convert(:upcase) }
           assert_equal ['foo', '"foo" # bar'], @values.map(&:to_s)
         end
 
-        should "not alter the value when using a ghost method" do
+        it "should not alter the value when using a ghost method" do
           @values.each { |v| v.convert_upcase }
           assert_equal ['foo', '"foo" # bar'], @values.map(&:to_s)
         end
       end
       
-      context "#convert!" do
-        should "convert the value when given the name of a filter" do
+      describe "#convert!" do
+        it "should convert the value when given the name of a filter" do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert!(:upcase).to_s }
         end
         
-        should "alter the value when given the name of a filter" do
+        it "should alter the value when given the name of a filter" do
           @values.each { |v| v.convert!(:upcase) }
           assert_equal ['FOO', '"FOO" # bar'], @values.map(&:to_s)
         end
 
-        should "alter the value when using a ghost method" do
+        it "should alter the value when using a ghost method" do
           @values.each { |v| v.convert_upcase! }
           assert_equal ['FOO', '"FOO" # bar'], @values.map(&:to_s)
         end
         
       end
       
-      context "#to_s" do
-        should 'accept a :filter option and convert the values accordingly without changing the value' do
+      describe "#to_s" do
+        it 'should accept a :filter option and convert the values accordingly without changing the value' do
           assert_equal '"FOO" # bar', @values[1].to_s(:filter => :upcase)
           assert_equal '"foo" # bar', @values[1].to_s
         end

data/test/helper.rb

@@ -1,5 +1,4 @@
 
-require 'mini_shoulda'
 require 'minitest/autorun'
 require 'redgreen'
 require 'tempfile'

data/test/test_bibtex.rb

@@ -27,7 +27,7 @@ module BibTeX
       bib = BibTeX::Bibliography.open(Test.fixtures(:decoret), :debug => false)
       assert_equal(15, bib.length)
       assert_equal([BibTeX::Entry,BibTeX::Comment,BibTeX::String,BibTeX::Preamble], bib.data.map(&:class).uniq)
-      assert_equal(:py03, bib.data[0].key)
+      assert_equal('py03', bib.data[0].key)
       assert_equal(:article, bib[:py03].type)
       assert_equal("D\\'ecoret, Xavier", bib[:py03][:author].to_s)
       assert_equal('PyBiTex', bib[:py03][:title])
@@ -45,7 +45,7 @@ module BibTeX
     def test_bibdesk
       bib = BibTeX::Bibliography.open(Test.fixtures(:bibdesk), :debug => false)
       assert_equal 3, bib.length
-      assert_equal :rails, bib[0].key
+      assert_equal 'rails', bib[0].key
       assert_equal '2010-08-05 10:06:32 +0200', bib[:dragon]['date-modified']
     end
   
@@ -75,9 +75,8 @@ module BibTeX
     end
   
     def test_parse
-      file = File.read(Test.fixtures(:roundtrip))
       bib = BibTeX::Bibliography.new
-      bib.add(BibTeX::Element.parse(%q( @string{ pragprog = "The Pragmatic Booksehlf" } )))
+      bib.add(BibTeX::Element.parse(%q( @string{ pragprog = "The Pragmatic Bookshelf" } )))
       bib.add(BibTeX::Element.parse(<<-END))
       @book{rails,
         address = {Raleigh, North Carolina},
@@ -85,7 +84,7 @@ module BibTeX
         booktitle = {Agile Web Development with Rails},
         edition = {third},
         keywords = {ruby, rails},
-        publisher = {The Pragmatic Bookshelf},
+        publisher = pragprog,
         series = {The Facets of Ruby},
         title = {Agile Web Development with Rails},
         year = {2009}
@@ -95,7 +94,7 @@ module BibTeX
       assert_equal(2, bib.length)
       refute_nil(bib[:rails])
       bib.replace_strings
-      assert_equal(file.gsub(/[\s]+/, ''), bib[:rails].to_s.gsub(/[\s]+/, ''))
+			assert_equal 'The Pragmatic Bookshelf', bib['rails'].publisher
     end
   end
 

data/test/test_export.rb

@@ -1,7 +1,6 @@
 require 'helper.rb'
 
 require 'yaml'
-require 'json'
 
 module BibTeX
   class TestString < MiniTest::Unit::TestCase
@@ -17,13 +16,13 @@ module BibTeX
       yaml = YAML.load(bib.to_yaml)
       refute_nil(yaml)
       assert_equal(3, yaml.length)
-      assert_equal([:dragon, :pickaxe, :rails], yaml.map { |y| y[:key] }.sort)
+      assert_equal(%w[ dragon pickaxe rails], yaml.map { |y| y[:key] }.sort)
       assert_equal('{The Facets of Ruby}', yaml[0][:series])
     end
   
     def test_json
       bib = BibTeX::Bibliography.open(Test.fixtures(:bibdesk), :debug => false)
-      json = JSON.parse(bib.to_json)
+      json = MultiJson.decode(bib.to_json)
       refute_nil(json)
       assert_equal(3, json.length)
       assert_equal(%w[ dragon pickaxe rails], json.map { |y| y['key'] }.sort)