bibtex-ruby 4.4.7 → 5.0.0

data/test/bibtex/test_filters.rb

@@ -2,31 +2,32 @@ require 'helper.rb'
 
 module BibTeX
   class FiltersTest < Minitest::Spec
-
-    it "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
 
     describe 'Filters.resolve' do
-      it "should return the filter if a filter is given" 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
+      it 'should return the parameter if it quacks like a filter' do
         f = Object.new
-        def f.apply; nil; end
+        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
+      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
+      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

@@ -1,42 +1,39 @@
-# 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]
+      assert_equal Lexer.new.analyse('@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']
+      Lexer.new.analyse(%(@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']
+      Lexer.new.analyse(%(@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]
+      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]
+      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]
+      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]
+      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]
+      Lexer.new.analyse('@preamblestring{ preamble }').symbols.must_be :==, [:AT, :NAME, :LBRACE, :NAME, :RBRACE, false]
     end
   end
 end

data/test/bibtex/test_name_parser.rb

@@ -2,7 +2,6 @@ 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.')
@@ -10,20 +9,18 @@ module BibTeX
       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")
+        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")
+        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
+      it 'should accept empty strings' do
+        assert_equal '', Names.parse('').to_s
       end
-
     end
-
   end
 end

data/test/bibtex/test_names.rb

@@ -1,17 +1,14 @@
-# coding: utf-8
-
 require 'helper'
 
 module BibTeX
   class NamesTest < Minitest::Spec
-
     before do
-      @poe = Name.new(:first => 'Edgar Allen', :last => 'Poe')
+      @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.')
+        @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
@@ -30,7 +27,7 @@ module BibTeX
       end
 
       it 'accepts the :initials option' do
-        @poe.display_order(:initials => true).must_be :==, 'E.A. Poe'
+        @poe.display_order(initials: true).must_be :==, 'E.A. Poe'
       end
     end
 
@@ -40,7 +37,7 @@ module BibTeX
       end
 
       it 'accepts the :initials option' do
-        @poe.sort_order(:initials => true).must_be :==, 'Poe, E.A.'
+        @poe.sort_order(initials: true).must_be :==, 'Poe, E.A.'
       end
     end
 
@@ -64,26 +61,26 @@ module BibTeX
 
     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.'
+        @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.'
+        @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.'
+        @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.'
+        @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.'
+        @poe.rename_if(first: 'E.A.') { |_n| false }.first.wont_equal 'E.A.'
       end
     end
 
@@ -96,73 +93,71 @@ module BibTeX
 
       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
+        n2 = Names.new(Name.new(last: 'Plato'))
+        assert_equal "#{@poe} 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.'
+        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: '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'
+        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.', 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.'
+        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'
+        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
+    describe 'conversions' do
       class UpcaseAll < BibTeX::Filter
-        def apply (value)
+        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'
+      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
-
+        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/test/bibtex/test_parser.rb

@@ -2,10 +2,9 @@ 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)))
+        @bib = Parser.new(debug: false).parse(File.read(Test.fixtures(:entry)))
       end
 
       it 'returns a Bibliography instance' do
@@ -18,11 +17,11 @@ module BibTeX
       end
 
       it 'parses the key values' do
-        assert_equal %w{ key:0 key:1 foo staudinger }, @bib.map(&:key)
+        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)
+        assert_equal %i[book article article commentary], @bib.map(&:type)
       end
 
       it 'should parse all values correctly' do
@@ -35,63 +34,62 @@ module BibTeX
         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 %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
+        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
+        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
+        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 'allows quotes in keys' do
-        input = %|@Misc{Gomez'1",title = {Foobar}}|
-        bib = Parser.new(:debug => false, :strict => false).parse(input)
-        assert_equal %{Gomez'1"}, bib.first.key
+        input = %(@Misc{Gomez'1",title = {Foobar}})
+        bib = Parser.new(debug: false, strict: false).parse(input)
+        assert_equal %(Gomez'1"), bib.first.key
         assert bib[:"Gomez'1\""]
       end
 
       it 'fails when there is no cite-key' do
-        input = "@misc{title = {Crime and Punishment}}"
+        input = '@misc{title = {Crime and Punishment}}'
         assert_raises ParseError do
-          Parser.new(:debug => false, :strict => false).parse(input)
+          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
+        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 :==, '{"}'
+        Parser.new.parse('@misc{key, title = "{"}"}')[0].title.must_be :==, '{"}'
       end
 
       it 'parses complex LaTeX markup' do
@@ -110,12 +108,11 @@ module BibTeX
         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)))
+        @bib = Parser.new(debug: false, include: [:meta_content]).parse(File.read(Test.fixtures(:comment)))
       end
 
       it 'should parses all @comments' do
@@ -128,13 +125,13 @@ module BibTeX
 
       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
+        assert_equal %(\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)))
+        @bib = Parser.new(debug: false).parse(File.read(Test.fixtures(:preamble)))
       end
 
       it 'should parse all @preambles' do
@@ -150,8 +147,8 @@ module BibTeX
 
     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}]
+        @braces = %(@TechReport{key,\n  author = {Donald,\n     Duck}\n})
+        @string = %(@TechReport{key,\n  author = "Donald,\n     Duck"\n})
       end
 
       it 'should parse string literals' do
@@ -161,18 +158,17 @@ module BibTeX
       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
+                     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
+                     Parser.new.parse('@article{x,  year = { 1993 }}')['x'].year.to_i
       end
     end