bibtex-ruby 2.0.1 → 2.0.2

data/lib/bibtex/lexer.rb

@@ -260,27 +260,27 @@ module BibTeX
 		end
 
 		def error_unbalanced_braces
-			Log.warn("Lexer: unbalanced braces at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			BibTeX.log.warn("Lexer: unbalanced braces at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
 			backtrace [:E_UNBALANCED, @scanner.matched]
 		end
 		
 		def error_unterminated_string
-			Log.warn("Lexer: unterminated string at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			BibTeX.log.warn("Lexer: unterminated string at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
 			backtrace [:E_UNTERMINATED_STRING, @scanner.matched]
 		end
 
 		def error_unterminated_content
-			Log.warn("Lexer: unterminated content at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			BibTeX.log.warn("Lexer: unterminated content at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
 			backtrace [:E_UNTERMINATED_CONTENT, @scanner.matched]
 		end
 		
 		def error_unexpected_token
-			Log.warn("Lexer: unexpected token `#{@scanner.matched}' at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			BibTeX.log.warn("Lexer: unexpected token `#{@scanner.matched}' at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
 			backtrace [:E_UNEXPECTED_TOKEN, @scanner.matched]
 		end
 
 		def error_unexpected_object
-			Log.warn("Lexer: unexpected object at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			BibTeX.log.warn("Lexer: unexpected object at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
 			backtrace [:E_UNEXPECTED_OBJECT, '@']
 		end
 

data/lib/bibtex/names.rb

@@ -109,7 +109,8 @@ module BibTeX
 			:suffix => :lineage
 		}.freeze
 		
-    def_delegators :to_s, :=~, :===, *(String.instance_methods(false).reject { |m| m =~ /^\W|each|first|last|!$/ })
+    def_delegators :to_s, :=~, :===,
+			*String.instance_methods(false).reject { |m| m =~ /^\W|to_s|replace|each|first|last|!$/ }
     
     class << self    
       def parse(string)

data/lib/bibtex/value.rb

@@ -103,7 +103,7 @@ module BibTeX
         when ::String # simulates Ruby's String#replace
           @tokens = [argument]
         when String
-         	@tokens = @tokens.map { |v| argument.key == v ? argument.value.tokens : v }.flatten
+          @tokens = @tokens.map { |v| argument.key == v ? argument.value.tokens : v }.flatten
         when Hash
           @tokens = @tokens.map { |v| argument[v] || v }
         end
@@ -112,12 +112,11 @@ module BibTeX
     end
 
 
-    # Returns the Value instance with all consecutive String tokens joined.
-    #
     # call-seq:
-    # Value.new('foo', 'bar').join #=> <'foobar'>
-    # Value.new(:foo, 'bar').join  #=> <:foo, 'bar'>
+    #   Value.new('foo', 'bar').join #=> <'foobar'>
+    #   Value.new(:foo, 'bar').join  #=> <:foo, 'bar'>
     #
+    # Returns the Value instance with all consecutive String tokens joined.
     def join
       @tokens = @tokens.inject([]) do |a,b|
         a[-1].is_a?(::String) && b.is_a?(::String) ? a[-1] += b : a << b; a
@@ -125,6 +124,16 @@ module BibTeX
       self
     end
     
+    # call-seq:
+    #   Value.new('foo').to_s                       #=> "foo"
+    #   Value.new(:foo).to_s                        #=> "foo"
+    #   Value.new('foo').to_s(:quotes => '"')       #=> "\"foo\""
+    #   Value.new('foo').to_s(:quotes => ['"','"']) #=> "\"foo\""
+    #   Value.new('foo').to_s(:quotes => ['{','}']) #=> "{foo}"
+    #   Value.new(:foo, 'bar').to_s                 #=> "foo # \"bar\""
+    #   Value.new('foo', 'bar').to_s                #=> "\"foo\" # \"bar\""
+    #   Value.new('\"u').to_s(:filter => :latex)    #=> "ü"
+    #
     # Returns a the Value as a string. @see #value; the only difference is
     # that single symbols are returned as String, too.
     # If the Value is atomic and the option :quotes is given, the string
@@ -132,17 +141,6 @@ module BibTeX
     #
     # If the option :filter is given, the Value will be converted using
     # the filter(s) specified.
-    #
-    # call-seq:
-    # Value.new('foo').to_s                       #=> "foo"
-    # Value.new(:foo).to_s                        #=> "foo"
-    # Value.new('foo').to_s(:quotes => '"')       #=> "\"foo\""
-    # Value.new('foo').to_s(:quotes => ['"','"']) #=> "\"foo\""
-    # Value.new('foo').to_s(:quotes => ['{','}']) #=> "{foo}"
-    # Value.new(:foo, 'bar').to_s                 #=> "foo # \"bar\""
-    # Value.new('foo', 'bar').to_s                #=> "\"foo\" # \"bar\""
-    # Value.new('\"u').to_s(:filter => :latex)    #=> "ü"
-    #
     def to_s(options = {})
       return convert(options.delete(:filter)).to_s(options) if options.has_key?(:filter)
       return value.to_s unless options.has_key?(:quotes) && atomic?
@@ -161,7 +159,7 @@ module BibTeX
     alias :v :value
 
     def inspect
-      '<' + @tokens.map(&:inspect).join(', ') + '>'
+      "#<#{self.class} #{tokens.map(&:inspect).join(', ')}>"
     end
     
     # Returns true if the Value is empty or consists of a single token.
@@ -173,7 +171,6 @@ module BibTeX
     def name?; false; end
     
     alias :names? :name?
-    alias :is_name? :name?
     
     def to_name
       Names.parse(to_s)
@@ -181,24 +178,24 @@ module BibTeX
     
     alias to_names to_name
 
-    # Returns true if the Value's content looks like a date.    
+    # Returns true if the Value's content is a date.    
     def date?
+      !to_date.nil?
     end
-
-    alias is_date? date?
     
-    # Returns the string as a citeproc date. TODO use edtf format instead.
+    # Returns the string as a date.
     def to_date
-      numeric? ? { 'date-parts' => [[to_i]] } : { 'literal' => to_s(:quotes => [])}
+      require 'date'
+      Date.parse(to_s)
+    rescue
+      nil
     end
-    
+        
     # Returns true if the Value's content is numeric.
     def numeric?
       to_s =~ /^\s*[+-]?\d+[\/\.]?\d*\s*$/
     end
-    
-    alias is_numeric? numeric?
-    
+        
     def to_citeproc (options = {})
       to_s(options)
     end
@@ -225,27 +222,27 @@ module BibTeX
     # Converts all string values according to the given filter.
     def convert! (filter)
       if f = Filters.resolve(filter)
-				tokens.map! { |t| f.apply(t) }
-			else
-				raise ArgumentError, "Failed to load filter #{filter.inspect}"
+        tokens.map! { |t| f.apply(t) }
+      else
+        raise ArgumentError, "Failed to load filter #{filter.inspect}"
       end
       
       self
     end
     
-		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 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 = '2.0.1'.freeze
+    STRING = '2.0.2'.freeze
   end
 end

data/test/bibtex/test_bibliography.rb

@@ -30,11 +30,11 @@ module BibTeX
 
     end
 
-		describe '.parse' do
-			it 'accepts filters' do
-				Bibliography.parse("@misc{k, title = {\\''u}}", :filter => 'latex')[0].title.must_be :==, 'ü'					
-			end
-		end
+    describe '.parse' do
+      it 'accepts filters' do
+        Bibliography.parse("@misc{k, title = {\\''u}}", :filter => 'latex')[0].title.must_be :==, 'ü'         
+      end
+    end
     
     describe 'given a populated biliography' do
       before do
@@ -66,41 +66,41 @@ module BibTeX
         END
       end
       
-      it 'should support access by index' do
+      it 'supports access by index' do
         assert_equal 'ruby', @bib[1].keywords 
       end
       
-      it 'should support access by range' do
+      it 'supports access by range' do
         assert_equal %w{2008 2007}, @bib[1..2].map(&:year)
       end
 
-      it 'should support access by index and offset' do
+      it 'supports access by index and offset' do
         assert_equal %w{2008 2007}, @bib[1,2].map(&:year)
       end
       
-      it 'should support queries by symbol key' do
+      it 'supports queries by symbol key' do
         refute_nil @bib[:rails]
         assert_nil @bib[:ruby]
       end
 
-      it 'should support queries by symbol key and selector' do
+      it 'supports 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
       
-      it 'should support queries by string key' do
+      it 'supports queries by string key' do
         refute_nil @bib['rails']
         assert_nil @bib['ruby']
       end
 
-      it 'should support queries by type string' do
+      it 'supports queries by type string' do
         assert_equal 2, @bib['@book'].length
         assert_equal 1, @bib['@article'].length
         assert_equal 0, @bib['@collection'].length
       end
 
-      it 'should support queries by type string and selector' do
+      it 'supports 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
@@ -110,16 +110,16 @@ module BibTeX
       end
 
 
-      it 'should support queries by pattern' do
+      it 'supports queries by pattern' do
         assert_equal 0, @bib[/reilly/].length
         assert_equal 2, @bib[/reilly/i].length
       end
       
-      it 'should support queries by type string and conditions' do
+      it 'supports queries by type string and conditions' do
         assert_equal 1, @bib['@book[keywords=ruby]'].length
       end
 
-      it 'should support queries by bibtex element' do
+      it 'supports queries by bibtex element' do
         entry = Entry.parse(<<-END).first
         @article{segaran2007,
           title = {{Programming collective intelligence}},
@@ -133,11 +133,11 @@ module BibTeX
         assert_equal 0, @bib[entry].length
       end
       
-      it 'should support query and additional block' do
+      it 'supports query and additional block' do
         assert_equal 1, @bib.q('@book') { |e| e.keywords.split(/,/).length > 1 }.length
       end
     
-      it 'should support saving the bibliography to a file' do
+      it 'supports saving the bibliography to a file' do
         tmp = Tempfile.new('bibtex')
         tmp.close
         @bib.save_to(tmp.path)
@@ -163,38 +163,38 @@ module BibTeX
         
       end
       
-			describe 'LaTeX filter' do
-				before do
-					@bib['rails'].keywords = 'r\\"uby'
-				end
-				
-				it 'converts LaTeX umlauts' do
-					@bib.convert(:latex)['rails'].keywords.must_be :==, 'rüby'
-				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
+      describe 'LaTeX filter' do
+        before do
+          @bib['rails'].keywords = 'r\\"uby'
+        end
+        
+        it 'converts LaTeX umlauts' do
+          @bib.convert(:latex)['rails'].keywords.must_be :==, 'rüby'
+        end
+        
+      end
+      
+      describe 'BibTeXML export' do
+        before { @bibtexml = Tempfile.new('bibtexml') }
+        after  { @bibtexml.unlink }
+          
+        it 'supports 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
+        it 'supports 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
         
     

data/test/bibtex/test_entry.rb

@@ -11,140 +11,146 @@ module BibTeX
       end
     end
 
-		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 '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_referenced?' 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 '#respond_to?' do
+          it 'takes into account the inherited attributes' do
+            @bib['a1'].respond_to?(:title)
+          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 '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
+          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 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
-		
+      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
@@ -254,36 +260,36 @@ module BibTeX
         
       end
       
-			describe 'LaTeX filter' do
-				before do
-					@entry.title = 'M\\"{o}by Dick'
-				end
-				
-				describe '#convert' do
-					it 'converts LaTeX umlauts' do
-						@entry.convert(:latex).title.must_be :==, 'Möby Dick'
-					end
-					
-					it 'does not change the original entry' do
-						e = @entry.convert(:latex)
-						e.wont_be :==, @entry
-						e.title.to_s.length.must_be :<, @entry.title.to_s.length
-					end
-				end
+      describe 'LaTeX filter' do
+        before do
+          @entry.title = 'M\\"{o}by Dick'
+        end
+        
+        describe '#convert' do
+          it 'converts LaTeX umlauts' do
+            @entry.convert(:latex).title.must_be :==, 'Möby Dick'
+          end
+          
+          it 'does not change the original entry' do
+            e = @entry.convert(:latex)
+            e.wont_be :==, @entry
+            e.title.to_s.length.must_be :<, @entry.title.to_s.length
+          end
+        end
 
-				describe '#convert!' do
-					it 'converts LaTeX umlauts' do
-						@entry.convert!(:latex).title.must_be :==, 'Möby Dick'
-					end
-					
-					it 'changes the original entry in-place' do
-						e = @entry.convert!(:latex)
-						e.must_be :equal?, @entry
-						e.title.to_s.length.must_be :==, @entry.title.to_s.length
-					end
-				end
-				
-			end
+        describe '#convert!' do
+          it 'converts LaTeX umlauts' do
+            @entry.convert!(:latex).title.must_be :==, 'Möby Dick'
+          end
+          
+          it 'changes the original entry in-place' do
+            e = @entry.convert!(:latex)
+            e.must_be :equal?, @entry
+            e.title.to_s.length.must_be :==, @entry.title.to_s.length
+          end
+        end
+        
+      end
     end
 
     describe 'citeproc export' do
@@ -393,57 +399,57 @@ module BibTeX
 
     end
   
-		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
+    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 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 '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
-		
+      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
 end