bibtex-ruby 1.3.12 → 2.0.0pre1

data/lib/bibtex/error.rb

@@ -1,6 +1,15 @@
 module BibTeX
 
-  class ParseError < StandardError; end
+	class BibTeXError < StandardError	
+		attr_reader :orginal
+		
+		def initialize(message = nil, original = $!)
+			super(message)
+			@original = original
+		end
+	end
+	
+  class ParseError < BibTeXError; end
   
   #
   # Represents a lexical or syntactical error.
@@ -12,7 +21,7 @@ module BibTeX
     def initialize(trace=[])
       @trace = trace
     end
-
+  
     def trace=(trace)
       raise(ArgumentError, "BibTeX::Error trace must be of type Array; was: #{trace.class.name}.") unless trace.kind_of?(Array)
       @trace = trace

data/lib/bibtex/lexer.rb

@@ -95,10 +95,10 @@ module BibTeX
 		def push(value)
 			case value[0]
       when :CONTENT, :STRING_LITERAL
-        if !@stack.empty? && value[0] == @stack[-1][0]
-				  @stack[-1][1] << value[1]
+				if !@stack.empty? && value[0] == @stack[-1][0]
+					@stack[-1][1] << value[1]
 				else
-  				@stack.push(value)
+					@stack.push(value)
 				end
 			when :ERROR
 				@stack.push(value) if @include_errors
@@ -119,10 +119,10 @@ module BibTeX
 
 			self.data = string || @scanner.string
 			
-      until @scanner.eos?
-        send("parse_#{MODE[@mode]}")
+			until @scanner.eos?
+				send("parse_#{MODE[@mode]}")
 			end
-			
+
 			push([false, '$end'])
 		end
 
@@ -130,7 +130,7 @@ module BibTeX
     
 		def parse_bibtex
 			case
-			when @scanner.scan(/[\t\r\n\s]+/o)
+			when @scanner.scan(/[\s]+/o)
 			when @scanner.scan(/\{/o)
 				@brace_level += 1
 				push([:LBRACE,'{'])
@@ -146,7 +146,7 @@ module BibTeX
 				push([:COMMA,','])
 			when @scanner.scan(/\d+/o)
 				push([:NUMBER,@scanner.matched])
-			when @scanner.scan(/[a-z\d \/:_!$\.%&*-]+/io)
+			when @scanner.scan(/[[:alpha:]\d \/:_!$\.%&*-]+/io)
 				push([:NAME,@scanner.matched.rstrip])
 			when @scanner.scan(/"/o)
 				@mode = :literal

data/lib/bibtex/names.rb

@@ -26,7 +26,10 @@ module BibTeX
     def_delegators :@tokens, :each, :sort
     
     def self.parse(string)
-      Names.new(NameParser.new.parse(string))
+      new(NameParser.new.parse(string))
+		rescue => e
+			BibTeX.log.info(e.message)
+			nil
     end
     
     def initialize(*arguments)
@@ -49,7 +52,7 @@ module BibTeX
       q = [options[:quotes]].flatten
       [q[0], value, q[-1]].compact.join
     end
-    
+
     def name?; true; end
     def numeric?; false; end
     def atomic?; true; end
@@ -91,8 +94,15 @@ module BibTeX
   class Name < Struct.new(:first, :last, :prefix, :suffix)
     extend Forwardable
     include Comparable
-    
-    def_delegators :to_s, :empty?, :=~, :casecmp, :match, :length, :intern, :to_sym, :end_with?, :start_with?, :include?, :upcase, :downcase, :reverse, :chop, :chomp, :rstrip, :gsub, :sub, :size, :strip, :succ, :to_str, :split, :each_byte, :each_char, :each_line
+
+    BibTeXML = {
+			:first  => :first,
+			:last   => :last,
+			:prefix => :prelast,
+			:suffix => :lineage
+		}.freeze
+		
+    def_delegators :to_s, :=~, :===, *(String.instance_methods(false).reject { |m| m =~ /^\W|each|!$/ })
     
     class << self    
       def parse(string)
@@ -140,6 +150,21 @@ module BibTeX
       Hash[each_pair.to_a]
     end
 
+		def to_xml
+			require 'rexml/document'			
+			xml = REXML::Element.new('bibtex:person')
+
+			each_pair do |part, text|
+				unless text.nil?
+					element = REXML::Element.new("bibtex:#{BibTeXML[part]}")
+					element.text = text
+					xml.add_element(element)
+				end
+			end
+			
+			xml
+		end
+    
     [:strip!, :upcase!, :downcase!, :sub!, :gsub!, :chop!, :chomp!, :rstrip!].each do |method_id|
       define_method(method_id) do |*arguments, &block|
         each do |part|

data/lib/bibtex/value.rb

@@ -52,7 +52,7 @@ module BibTeX
     attr_reader :tokens
     alias to_a tokens
     
-    def_delegators :to_s, :empty?, :=~, :match, :intern, :to_sym, :to_i, :to_f, :end_with?, :start_with?, :include?, :upcase, :downcase, :reverse, :chop, :chomp, :rstrip, :gsub, :sub, :size, :strip, :succ, :to_c, :to_r, :to_str, :split, :each_byte, :each_char, :each_line
+    def_delegators :to_s, :=~, :===, *String.instance_methods(false).reject { |m| m =~ /^\W|^length$|!$/ }
     def_delegators :@tokens, :[], :length
     
     def initialize(*arguments)
@@ -236,19 +236,19 @@ module BibTeX
       self
     end
     
-    def method_missing (name, *args)
-      if name.to_s =~ /^(?:convert|from)_([a-z]+)(!)?$/
-        return $2 ? convert!($1) : convert($1)
-      end
-      
-		  super
+		def method_missing (name, *args)
+			case
+			when name.to_s =~ /^(?:convert|from)_([a-z]+)(!)?$/
+				$2 ? convert!($1) : convert($1)
+			else
+				super
+			end
 		end
 		
 		def respond_to? (method)
 		  method =~ /^(?:convert|from)_([a-z]+)(!)?$/ || super
 		end
-		
-    
+		    
     def <=> (other)
       to_s <=> other.to_s
     end

data/lib/bibtex/version.rb

@@ -18,6 +18,6 @@
 
 module BibTeX
   module Version
-    STRING = '1.3.12'.freeze
+    STRING = '2.0.0pre1'.freeze
   end
 end

data/lib/bibtex/version.rbc

@@ -1,5 +1,5 @@
 !RBIX
-9595534255132031488
+16846133056282117387
 x
 M
 1
@@ -155,7 +155,7 @@ x
 STRING
 s
 6
-1.3.11
+1.3.12
 x
 6
 freeze

data/test/bibtex/test_bibliography.rb

@@ -1,20 +1,22 @@
+# -*- encoding: utf-8 -*-
+
 require 'helper'
 
 module BibTeX
   
   class BibliographyTest < MiniTest::Spec
     
-    context 'when newly created' do
-      should 'not be nil' do
+    describe 'when newly created' do
+      it 'should not be nil' do
         assert Bibliography.new
       end
-      should 'be empty' do
+      it 'should be empty' do
         assert Bibliography.new.empty?
       end
     end
 
-    context '#open' do
-      should 'accept a block and save the file after execution' do
+    describe '.open' do
+      it 'should accept 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)
@@ -25,10 +27,17 @@ module BibTeX
         
         assert_equal b.length - 1, BibTeX.open(tmp.path).length
       end
+
     end
+
+		describe '.parse' do
+			it 'should accept filters' do
+				Bibliography.parse("@misc{k, title = {\\''u}}", :filter => 'latex')[0].title.must_be :==, 'ü'					
+			end
+		end
     
-    context 'given a populated biliography' do
-      setup do
+    describe 'given a populated biliography' do
+      before do
         @bib = BibTeX.parse <<-END
         @book{rails,
           address = {Raleigh, North Carolina},
@@ -57,41 +66,41 @@ module BibTeX
         END
       end
       
-      should 'support access by index' do
+      it 'should support access by index' do
         assert_equal 'ruby', @bib[1].keywords 
       end
       
-      should 'support access by range' do
+      it 'should support access by range' do
         assert_equal %w{2008 2007}, @bib[1..2].map(&:year)
       end
 
-      should 'support access by index and offset' do
+      it 'should support access by index and offset' do
         assert_equal %w{2008 2007}, @bib[1,2].map(&:year)
       end
       
-      should 'support queries by symbol key' do
+      it 'should support queries by symbol key' do
         refute_nil @bib[:rails]
         assert_nil @bib[:ruby]
       end
 
-      should 'support queries by symbol key and selector' do
+      it 'should support 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
       
-      should 'support queries by string key' do
-        assert_equal 1, @bib['rails'].length
-        assert_equal 0, @bib['ruby'].length
+      it 'should support queries by string key' do
+        refute_nil @bib['rails']
+        assert_nil @bib['ruby']
       end
 
-      should 'support queries by type string' do
+      it 'should support queries by type string' do
         assert_equal 2, @bib['@book'].length
         assert_equal 1, @bib['@article'].length
         assert_equal 0, @bib['@collection'].length
       end
 
-      should 'support queries by type string and selector' do
+      it 'should support 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
@@ -101,16 +110,16 @@ module BibTeX
       end
 
 
-      should 'support queries by pattern' do
+      it 'should support queries by pattern' do
         assert_equal 0, @bib[/reilly/].length
         assert_equal 2, @bib[/reilly/i].length
       end
       
-      should 'support queries by type string and conditions' do
+      it 'should support queries by type string and conditions' do
         assert_equal 1, @bib['@book[keywords=ruby]'].length
       end
 
-      should 'support queries by bibtex element' do
+      it 'should support queries by bibtex element' do
         entry = Entry.parse(<<-END).first
         @article{segaran2007,
           title = {{Programming collective intelligence}},
@@ -124,40 +133,59 @@ module BibTeX
         assert_equal 0, @bib[entry].length
       end
       
-      should 'support query and additional block' do
+      it 'should support query and additional block' do
         assert_equal 1, @bib.q('@book') { |e| e.keywords.split(/,/).length > 1 }.length
       end
     
-      should 'support saving the bibliography to a file' do
+      it 'should support saving the bibliography to a file' do
         tmp = Tempfile.new('bibtex')
         tmp.close
         @bib.save_to(tmp.path)
-        assert_equal @bib.to_s, BibTeX.open(tmp.path).to_s
+        assert_equal @bib.length, BibTeX.open(tmp.path).length
       end
       
-      context 'given a filter' do
-        setup do
+      describe 'given a filter' do
+        before do
           @filter = Object
           def @filter.apply (value); value.is_a?(::String) ? value.upcase : value; end
         end
           
-        should 'support arbitrary conversions' do
+        it 'should support arbitrary conversions' do
           @bib.convert(@filter)
           assert_equal 'RUBY, RAILS', @bib[:rails].keywords
         end
         
-        should 'support conditional arbitrary conversions' do
-          @bib.convert(@filter) { |e| e.key != :rails }
+        it 'should support 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 'BibTeXML export' do
+				before { @bibtexml = Tempfile.new('bibtexml') }
+				after  { @bibtexml.unlink }
+					
+				it 'should support 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 'should support 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
-    
-    
-    
+        
     
   end
 end

data/test/bibtex/test_elements.rb

@@ -2,31 +2,55 @@ require 'helper'
 
 module BibTeX
   
+	class ElementTest < MiniTest::Spec
+		
+		describe '.parse' do
+			
+			it 'accepts a BibTeX string' do
+				Element.parse('@misc{x,},@misc{y,}').length.must_be :==, 2
+			end
+			
+			it 'accepts an Element' do
+				Element.parse(Comment.new('blah')).length.must_be :==, 1
+			end
+			
+			it 'accepts a Hash and returns an Entry' do
+				Element.parse({ :type => :book })[0].type.must_be :==, :book
+			end
+			
+			it 'accepts an array of hashes' do
+				Element.parse([{ :type => :book }, { :type => :misc }])[1].type.must_be :==, :misc
+			end
+			
+		end
+		
+	end
+
   class PreambleTest < MiniTest::Spec
     
-    context 'a new preamble instance' do
-      setup do
+    describe 'a new preamble instance' do
+      before do
         @preamble = Preamble.new
       end
       
-      should 'not be nil' do
+      it 'should not be nil' do
         assert @preamble
       end
     end
     
-    context 'given a set of @preambles' do
-      setup do
+    describe 'given a set of @preambles' do
+      before do
         @bib = BibTeX.open(Test.fixtures(:preamble))
         @preambles = @bib.preambles
       end
       
-      should 'support round-trips of all parsed preambles' do
+      it '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
+      it '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

data/test/bibtex/test_entry.rb

@@ -3,37 +3,171 @@ require 'helper.rb'
 module BibTeX
   class EntryTest < MiniTest::Spec
 
-    context 'a new entry' do
-      should 'not be nil' do
-        assert Entry.new
+    describe 'a new entry' do
+      it "won't be nil" do
+        Entry.new.wont_be_nil
       end
     end
 
-    context 'month conversion' do
-      setup do
+		describe 'cross-references' do
+			it 'has no cross-reference by default' do
+				assert_equal false, Entry.new.has_cross_reference?
+			end
+			
+			it 'is not cross-referenced by default' do
+				assert_equal false, Entry.new.cross_referenced?
+				Entry.new.cross_referenced_by.must_be_empty
+			end
+			
+			describe 'given a bibliography with cross referenced entries' do
+				before do
+					@bib = Bibliography.parse <<-END
+						@book{a, editor = "A", title = "A"}
+						@incollection{a1, crossref = "a"}
+						@incollection{b1, crossref = "b"}
+					END
+				end
+				
+				describe '#has_cross_reference?' do
+					it 'returns true if the entry has a valid cross-reference' do
+						assert_equal true, @bib['a1'].has_cross_reference?
+					end
+					it 'returns false if the entry has no valid cross-reference' do
+						assert_equal false, @bib['a'].has_cross_reference?
+						assert_equal false, @bib['b1'].has_cross_reference?
+					end
+				end
+				
+				describe '#cross_referemced?' do
+					it 'returns true if the entry is cross-referenced by another entry' do
+						assert_equal true, @bib['a'].cross_referenced?
+					end
+					it 'returns false if the entry is not cross-referenced' do
+						assert_equal false, @bib['a1'].cross_referenced?
+					end
+				end
+				
+				describe '#cross_referenced_by' do
+					it 'returns a list of all entries that cross-reference this entry' do
+						@bib['a'].cross_referenced_by.must_include(@bib['a1'])
+					end
+					
+					it 'returns an empty list if there are no cross-references to this entry' do
+						@bib['a1'].cross_referenced_by.must_be_empty
+					end
+				end
+				
+				describe 'resolve field values using array accessors #[]' do
+					describe 'when a "title" is set in the entry itself' do
+						before { @bib['a1'].title = 'A1' }
+						it 'returns the title' do
+							@bib['a1'].title.must_be :==, 'A1'
+						end
+					end
+					
+					describe 'when "title" is undefined for the entry but defined in the reference' do
+						it 'returns the referenced title' do
+							@bib['a1'].title.must_be :==, @bib['a'].title
+						end
+					end
+					
+					describe 'when "booktitle" is undefined for the entry but defined in the reference' do
+						before { @bib['a'].booktitle = "A Booktitle" }
+						it 'returns the referenced booktitle' do
+							@bib['a1'].booktitle.must_be :==, @bib['a'].booktitle
+						end
+					end
+
+					describe 'when "booktitle" is undefined for the entry and the reference but the reference has a "title"' do
+						it "returns the reference's title" do
+							@bib['a1'].booktitle.must_be :==, @bib['a'].title
+						end
+					end
+					
+					it 'does not store referenced values permanently' do
+						refute_nil @bib['a1'].booktitle
+						assert_nil @bib['a1'].fields[:booktitle]
+					end
+
+					describe '#inherited_fields' do
+						it 'returns an empty list by default' do
+							Entry.new.inherited_fields.must_be_empty
+						end
+						
+						it 'returns an empty list if this entry has no cross-reference' do
+							@bib['a'].inherited_fields.must_be_empty
+						end
+						
+						it 'returns an empty list if this entry has a cross-reference but the reference does not exist in the bibliography' do
+							@bib['b1'].inherited_fields.must_be_empty
+						end
+						
+						it 'returns a list of all fields not set in the field but in the reference' do
+							@bib['a1'].inherited_fields.must_be :==, [:booktitle, :editor, :title]
+						end
+					end
+					
+					describe '#save_inherited_fields' do
+						it 'copies referenced values to the entry' do
+							@bib['a1'].title = 'a1'
+							@bib['a1'].save_inherited_fields
+							@bib['a1'].fields[:booktitle].must_be :==, @bib['a'].title
+							@bib['a1'].fields[:title].wont_be :==, @bib['a'].title
+						end
+					end
+				end
+				
+			end
+		end
+		
+		describe '#names' do
+			it 'returns an empty list by default' do
+				Entry.new.names.must_be :==, []
+			end
+			
+			it 'returns the author (if set)' do
+				Entry.new(:author => 'A').names.must_be :==, %w{ A }
+			end
+
+			it 'returns all authors (if set)' do
+				Entry.new(:author => 'A B and C D').parse_names.names.length.must_be :==, 2
+			end
+			
+			it 'returns the editor (if set)' do
+				Entry.new(:editor => 'A').names.must_be :==, %w{ A }
+			end
+
+			it 'returns the translator (if set)' do
+				Entry.new(:translator => 'A').names.must_be :==, %w{ A }
+			end
+			
+		end
+		
+    describe 'month conversion' do
+      before do
         @entry = Entry.new
       end
       
       [[:jan,'January'], [:feb,'February'], [:sep,'September']].each do |m|
-        should 'convert english months' do
+        it 'should convert english months' do
           @entry.month = m[1]
           assert_equal m[0], @entry.month.v
         end
       end
 
       [[:jan,:jan], [:feb,:feb], [:sep,:sep]].each do |m|
-        should 'convert bibtex abbreviations' do
+        it 'should convert bibtex abbreviations' do
           @entry.month = m[1]
           assert_equal m[0], @entry.month.v
         end
       end
 
       [[:jan,1], [:feb,2], [:sep,9]].each do |m|
-        should 'convert numbers' do
+        it 'should convert numbers' do
           @entry.month = m[1]
           assert_equal m[0], @entry.month.v
         end
-        should 'convert numbers when parsing' do
+        it 'should convert numbers when parsing' do
           @entry = Entry.parse("@misc{id, month = #{m[1]}}")[0]
           assert_equal m[0], @entry.month.v
         end
@@ -41,8 +175,8 @@ module BibTeX
       
     end
 
-    context 'given an entry' do
-      setup do
+    describe 'given an entry' do
+      before do
         @entry = Entry.new do |e|
           e.type = :book
           e.key = :key
@@ -56,13 +190,13 @@ module BibTeX
         end
       end
       
-      should 'support renaming! of field attributes' do
+      it 'should support renaming! of field attributes' do
         @entry.rename!(:title => :foo)
         refute @entry.has_field?(:title)
         assert_equal 'Moby Dick', @entry[:foo]
       end
 
-      should 'support renaming of field attributes' do
+      it 'should support renaming of field attributes' do
         e = @entry.rename(:title => :foo)
 
         assert @entry.has_field?(:title)
@@ -76,7 +210,7 @@ module BibTeX
       end
 
       
-      should 'support citeproc export' do
+      it 'should support citeproc export' do
         e = @entry.to_citeproc
         assert_equal 'book', e['type']
         assert_equal 'New York', e['publisher-place']
@@ -86,30 +220,30 @@ module BibTeX
         assert_equal 'Melville', e['author'][0]['family']
       end
       
-      context 'given a filter' do
-        setup do
+      describe 'given a filter' do
+        before do
           @filter = Object.new
           def @filter.apply (value); value.is_a?(::String) ? value.upcase : value; end
         end
         
-        should 'support arbitrary conversion' do
+        it 'should support arbitrary conversion' do
           e = @entry.convert(@filter)
           assert_equal 'MOBY DICK', e.title
           assert_equal 'Moby Dick', @entry.title
         end
 
-        should 'support arbitrary in-place conversion' do
+        it 'should support arbitrary in-place conversion' do
           @entry.convert!(@filter)
           assert_equal 'MOBY DICK', @entry.title
         end
 
-        should 'support conditional arbitrary in-place conversion' do
+        it 'should support conditional arbitrary in-place conversion' do
           @entry.convert!(@filter) { |k,v| k.to_s =~ /publisher/i  }
           assert_equal 'Moby Dick', @entry.title
           assert_equal 'PENGUIN', @entry.publisher
         end
 
-        should 'support conditional arbitrary conversion' do
+        it 'should support conditional arbitrary conversion' do
           e = @entry.convert(@filter) { |k,v| k.to_s =~ /publisher/i  }
           assert_equal 'Moby Dick', e.title
           assert_equal 'PENGUIN', e.publisher
@@ -120,8 +254,8 @@ module BibTeX
       
     end
 
-    context 'citeproc export' do
-      setup do
+    describe 'citeproc export' do
+      before do
         @entry = Entry.new do |e|
           e.type = :book
           e.key = :key
@@ -130,11 +264,11 @@ module BibTeX
         end
       end
       
-      should 'use dropping-particle by default' do
+      it 'should use dropping-particle by default' do
         assert_equal 'van', @entry.to_citeproc['author'][0]['dropping-particle']
       end
       
-      should 'accept option to use non-dropping-particle' do
+      it 'should accept option to use non-dropping-particle' do
         assert_equal 'van', @entry.to_citeproc(:particle => 'non-dropping-particle')['author'][0]['non-dropping-particle']
       end
     end
@@ -145,9 +279,9 @@ module BibTeX
       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('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)
@@ -180,7 +314,7 @@ module BibTeX
       entry.title = 'The Raven'
     
       assert_equal :book, entry.type
-      assert_equal :raven, entry.key
+      assert_equal 'raven', entry.key
       assert_equal 'Poe, Edgar A.', entry.author
       assert_equal 'The Raven', entry.title
     end
@@ -194,7 +328,7 @@ module BibTeX
       })
     
       assert_equal :book, entry.type
-      assert_equal :raven, entry.key
+      assert_equal 'raven', entry.key
       assert_equal 'Poe, Edgar A.', entry.author
       assert_equal 'The Raven', entry.title
     end
@@ -202,36 +336,81 @@ module BibTeX
     def test_creation_from_block
       entry = BibTeX::Entry.new do |e|
         e.type = :book
-        e.key = :raven
+        e.key = 'raven'
         e.author = 'Poe, Edgar A.'
         e.title = 'The Raven'
       end
     
       assert_equal :book, entry.type
-      assert_equal :raven, entry.key
+      assert_equal 'raven', entry.key
       assert_equal 'Poe, Edgar A.', entry.author
       assert_equal 'The Raven', entry.title
     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 << Entry.new({ :type => 'book', :key => 'raven3', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << Entry.new({ :type => 'book', :key => 'raven2', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << Entry.new({ :type => 'book', :key => 'raven1', :author => 'Poe, Edgar A.', :title => 'The Raven'})
+      entries << 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 ['raven1', 'raven1', 'raven2', 'raven3'], entries.map(&:key)
       assert_equal ['The Aven', 'The Raven'], entries.map(&:title)[0,2]
 
     end
   
-		def test_default_keys
-			assert_equal :poe1996raven, Entry.new(:type => 'book', :author => 'Poe, Edgar A.', :title => 'The Raven', :year => 1996).key
-			assert_equal :poe1996, Entry.new(:type => 'book', :author => 'Poe, Edgar A.', :year => 1996).key
-			assert_equal :'1996raven', Entry.new(:type => 'book', :title => 'The Raven', :year => 1996).key
-			assert_match /^\d+$/, Entry.new.key
+		describe 'default keys' do
+			before {
+				@e1 = Entry.new(:type => 'book', :author => 'Poe, Edgar A.', :title => 'The Raven', :editor => 'John Hopkins', :year => 1996)
+				@e2 = Entry.new(:type => 'book', :title => 'The Raven', :editor => 'John Hopkins', :year => 1996)
+				@e3 = Entry.new(:type => 'book', :author => 'Poe, Edgar A.', :title => 'The Raven', :editor => 'John Hopkins')
+			}
+	
+			it 'should return "unknown-a" for an empty Entry' do
+				Entry.new.key.must_be :==, 'unknown-a'
+			end
+	
+			it 'should return a key made up of author-year-a if all fields are present' do
+				@e1.key.must_be :==, 'poe1996a'
+			end
+
+			it 'should return a key made up of editor-year-a if there is no author' do
+				@e2.key.must_be :==, 'john1996a'
+			end
+
+			it 'should return use the last name if the author/editor names have been parsed' do
+				@e2.parse_names.key.must_be :==, 'hopkins1996a'
+			end
+
+			it 'skips the year if not present' do
+				@e3.key.must_be :==, 'poe-a'
+			end
+		end
+		
+		describe 'when the entry is added to a Bibliography' do
+			before {
+				@e = Entry.new
+				@bib = Bibliography.new
+			}
+			
+			it 'should register itself with its key' do
+				@bib << @e
+				@bib.entries.keys.must_include @e.key
+			end
+			
+			describe "when there is already an element registered with the entry's key" do
+				before { @bib << Entry.new }
+				
+				it "should find a suitable key" do
+					k = @e.key
+					@bib << @e
+					@bib.entries.keys.must_include @e.key
+					k.wont_be :==, @e.key
+				end
+				
+			end
 		end
 		
   end