bibtex-ruby 4.4.7 → 5.0.0

data/test/bibtex/test_string.rb

@@ -2,11 +2,10 @@ require 'helper.rb'
 
 module BibTeX
   class StringTest < Minitest::Spec
-
     describe 'when parsing a simple string' do
       before do
         @bib = BibTeX.parse('@string{ foo = "bar" }')
-      end        
+      end
       it 'should should not be empty' do
         assert_equal 1, @bib.length
       end
@@ -21,14 +20,14 @@ module BibTeX
       end
     end
 
-    # 
+    #
     # def test_replacement
     #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
     #   refute_nil(bib)
     #   assert(bib.kind_of?(BibTeX::Bibliography))
     #   refute(bib.empty?)
     #   assert_equal(7,bib.length)
-    #   assert_equal([BibTeX::String,BibTeX::Preamble,BibTeX::Entry], bib.data.map(&:class).uniq) 
+    #   assert_equal([BibTeX::String,BibTeX::Preamble,BibTeX::Entry], bib.data.map(&:class).uniq)
     #   assert_equal(["foo"], bib.strings[:foo])
     #   assert_equal(["bar"], bib.strings[:bar])
     #   assert_equal([:foo, "bar"], bib.strings[:foobar])
@@ -36,7 +35,7 @@ module BibTeX
     #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
     #   assert_equal('"foo" # foo # foobarfoo # "bar"', bib.preambles[0].content)
     #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
-    # 
+    #
     #   bib.replace_strings({ :filter => [:preamble]})
     #   assert_equal(["foo"], bib.strings[:foo])
     #   assert_equal(["bar"], bib.strings[:bar])
@@ -45,19 +44,19 @@ module BibTeX
     #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
     #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
     #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
-    # 
+    #
     #   bib.replace_strings({ :filter => [:string]})
     #   assert_equal(['foo','bar'], bib.strings[:foobar])
     #   assert_equal(['foo', 'bar','foo'], bib.strings[:foobarfoo])
     #   assert_equal(['bar','foo','bar'], bib.strings[:barfoobar])
     #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
     #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
-    # 
+    #
     #   bib.replace_strings({ :filter => [:preamble,:entry]})
     #   assert_equal('"foo" # "foo" # "foo" # "bar" # "foo" # "bar"', bib.preambles[0].content)
     #   assert_equal('"foo" # "bar" # "foo" # "bar"', bib[:'manual:1'].title)
     # end
-    #   
+    #
     # def test_roundtrip
     #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
     #   refute_nil(bib)
@@ -80,4 +79,4 @@ module BibTeX
     #   assert_equal('@string{ barfoobar = "barfoobar" }', bib.data[4].to_s)
     # end
   end
-end
+end

data/test/bibtex/test_utilities.rb

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

data/test/bibtex/test_value.rb

@@ -14,59 +14,58 @@ end
 
 module BibTeX
   class ValueTest < Minitest::Spec
-
-    describe "::create" do
-      it "should return a duplicate when called with a Value subclass" do
+    describe '::create' do
+      it 'should return a duplicate when called with a Value subclass' do
         val   = Value.new('value')
-        names = Names.new(Name.new(:first => 'first_name'))
+        names = Names.new(Name.new(first: 'first_name'))
 
         assert_equal val.dup,   Value.create(val)
         assert_equal names.dup, Value.create(names)
       end
 
-      it "should return a new Value object when called with other arguments" do
+      it 'should return a new Value object when called with other arguments' do
         assert_equal Value.new('value'), Value.create('value')
       end
     end
 
-    describe "when empty" do
-      it "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
-      it "should be empty" do
+      it 'should be empty' do
         assert Value.new.empty?
         assert Value.new('').empty?
       end
-      it "should match an empty pattern" do
+      it 'should match an empty pattern' do
         assert Value.new =~ //
         assert Value.new('') =~ //
       end
     end
 
-    describe "#join" do
-      it "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
-      it "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
-      it "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
+        assert_equal 'foobar', Value.new(%w[foo bar]).join.to_s
       end
-      it "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
-      it "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
-      it "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)
@@ -84,65 +83,65 @@ module BibTeX
       end
     end
 
-    describe "#to_s" do
-      it "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
-      it "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
-      it "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
-      it "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
-      it "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
 
-    describe "conversions" do
+    describe 'conversions' do
       before do
         @values = [Value.new('foo'), Value.new('foo', :bar)]
       end
 
-      describe "#convert" do
-        it "converts the value when given a filter instance" do
+      describe '#convert' do
+        it 'converts the value when given a filter instance' do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase.instance).to_s }
         end
 
-        it "converts the value when given a filter class" do
+        it 'converts the value when given a filter class' do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase).to_s }
         end
 
-        it "converts the value when given the name of a filter" do
+        it 'converts 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 }
           assert_equal ['fooa', '"fooa" # bar'], @values.map { |v| v.convert('suffixa').to_s }
         end
 
-        it "applies multiple filters in the order passed" do
+        it 'applies multiple filters in the order passed' do
           @values.map { |v| v.convert(:upcase, :suffixa).to_s }.must_equal ['FOOa', '"FOOa" # bar']
           @values.map { |v| v.convert(:suffixa, :upcase).to_s }.must_equal ['FOOA', '"FOOA" # bar']
         end
 
-        it "converts the value when using a ghost method" do
+        it 'converts the value when using a ghost method' do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert_upcase.to_s }
         end
 
-        it "does not alter the value when using a filter name" do
+        it 'does 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
 
-        it "does not alter the value when using a ghost method" do
-          @values.each { |v| v.convert_upcase }
+        it 'does not alter the value when using a ghost method' do
+          @values.each(&:convert_upcase)
           assert_equal ['foo', '"foo" # bar'], @values.map(&:to_s)
         end
 
-        it "raises argument error when a filter cannot be resolved" do
+        it 'raises argument error when a filter cannot be resolved' do
           assert_raises ArgumentError do
             @values[0].convert(:foo)
           end
@@ -153,23 +152,23 @@ module BibTeX
         end
       end
 
-      describe "#convert!" do
-        it "converts the value when given the name of a filter" do
+      describe '#convert!' do
+        it 'converts the value when given the name of a filter' do
           assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert!(:upcase).to_s }
         end
 
-        it "alters the value when given the name of a filter" do
+        it 'alters 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
 
-        it "alters the value when using a ghost method" do
-          @values.each { |v| v.convert_upcase! }
+        it 'alters the value when using a ghost method' do
+          @values.each(&:convert_upcase!)
           assert_equal ['FOO', '"FOO" # bar'], @values.map(&:to_s)
         end
       end
 
-      describe "value" do
+      describe 'value' do
         it 'returns numbers as strings' do
           assert Value.new(42).v.is_a?(::String)
           assert Value.new(-42).v.is_a?(::String)
@@ -177,13 +176,12 @@ module BibTeX
         end
       end
 
-      describe "#to_s" do
+      describe '#to_s' do
         it 'accepts 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(filter: :upcase)
           assert_equal '"foo" # bar', @values[1].to_s
         end
       end
     end
-
   end
 end

data/test/helper.rb

@@ -6,13 +6,12 @@ rescue LoadError
 end
 
 begin
-  case
-  when RUBY_PLATFORM < 'java'
+  if RUBY_PLATFORM < 'java'
     require 'debug'
     Debugger.start
-  when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
     require 'rubinius/debugger'
-  when defined?(RUBY_VERSION) && RUBY_VERSION < '2.0'
+  elsif defined?(RUBY_VERSION) && RUBY_VERSION < '2.0'
     require 'debugger'
   else
     require 'byebug'
@@ -32,12 +31,10 @@ require 'bibtex'
 
 module BibTeX
   module Test
-
     class << self
       def fixtures(name)
         File.expand_path("../fixtures/#{name}.bib", __FILE__)
       end
     end
-
   end
 end

data/test/macruby.rb

@@ -1,20 +1,19 @@
-
 # sudo dtrace -qs test/macruby.d -c "macruby -Ilib -rrubygems test/macruby.rb"
 
 require 'bibtex'
 
-input = <<-END
-@book{pickaxe,
-	Address = {Raleigh, North Carolina},
-	Author = {Thomas, Dave, and Fowler, Chad, and Hunt, Andy},
-	Date-Added = {2010-08-05 09:54:07 +0200},
-	Date-Modified = {2010-08-05 10:07:01 +0200},
-	Keywords = {ruby},
-	Publisher = {The Pragmatic Bookshelf},
-	Series = {The Facets of Ruby},
-	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
-	Year = {2009}
-}
+input = <<~END
+  @book{pickaxe,
+  	Address = {Raleigh, North Carolina},
+  	Author = {Thomas, Dave, and Fowler, Chad, and Hunt, Andy},
+  	Date-Added = {2010-08-05 09:54:07 +0200},
+  	Date-Modified = {2010-08-05 10:07:01 +0200},
+  	Keywords = {ruby},
+  	Publisher = {The Pragmatic Bookshelf},
+  	Series = {The Facets of Ruby},
+  	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
+  	Year = {2009}
+  }
 END
 
 lexer = BibTeX::Lexer.new

data/test/profile.rb

@@ -1,28 +1,28 @@
-require File.expand_path('../../lib/bibtex.rb', __FILE__)
+require File.expand_path('../lib/bibtex.rb', __dir__)
 
 require 'ruby-prof'
 
-data = <<-END
-@book{pickaxe,
-	Address = {Raleigh, North Carolina},
-	Author = "Thomas, Dave, and Fowler, Chad, and Hunt, Andy",
-	Date-Added = {2010-08-05 09:54:07 +0200},
-	Date-Modified = {2010-08-05 10:07:01 +0200},
-	Keywords = {ruby},
-	Publisher = {The Pragmatic Bookshelf},
-	Series = {The Facets of Ruby},
-	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
-	Year = {2009}
-}
+data = <<~END
+  @book{pickaxe,
+  	Address = {Raleigh, North Carolina},
+  	Author = "Thomas, Dave, and Fowler, Chad, and Hunt, Andy",
+  	Date-Added = {2010-08-05 09:54:07 +0200},
+  	Date-Modified = {2010-08-05 10:07:01 +0200},
+  	Keywords = {ruby},
+  	Publisher = {The Pragmatic Bookshelf},
+  	Series = {The Facets of Ruby},
+  	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
+  	Year = {2009}
+  }
 END
 
-data = data * 50
+data *= 50
 # data = File.open(File.expand_path('../fixtures/benchmark.bib', __FILE__)).read
 
 result = RubyProf.profile do
-	 BibTeX.parse(data)
+  BibTeX.parse(data)
   # BibTeX::Lexer.new.analyse(data)
 end
 
 printer = RubyProf::DotPrinter.new(result)
-printer.print(File.open(File.expand_path('../profile.dot', __FILE__), 'w'), :min_percent => 5)
+printer.print(File.open(File.expand_path('profile.dot', __dir__), 'w'), min_percent: 5)

data/test/test_bibtex.rb

@@ -3,31 +3,28 @@ require 'timeout'
 
 module BibTeX
   class TestBibtex < Minitest::Unit::TestCase
+    def setup; end
 
-    def setup
-    end
-
-    def teardown
-    end
+    def teardown; end
 
     def test_empty
-      bib = BibTeX::Bibliography.open(Test.fixtures(:empty), :debug => false)
+      bib = BibTeX::Bibliography.open(Test.fixtures(:empty), debug: false)
       refute_nil(bib)
       assert_equal(BibTeX::Bibliography, bib.class)
       assert(bib.empty?)
     end
 
     def test_no_bibtex
-      bib = BibTeX::Bibliography.open(Test.fixtures(:no_bibtex), :debug => false)
+      bib = BibTeX::Bibliography.open(Test.fixtures(:no_bibtex), debug: false)
       refute_nil(bib)
       assert_equal(BibTeX::Bibliography, bib.class)
       assert(bib.empty?)
     end
 
     def test_decoret
-      bib = BibTeX::Bibliography.open(Test.fixtures(:decoret), :debug => false)
+      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([BibTeX::Entry, BibTeX::Comment, BibTeX::String, BibTeX::Preamble], bib.data.map(&:class).uniq)
       assert_equal('py03', bib.data[0].key)
       assert_equal(:article, bib[:py03].type)
       assert_equal("D\\'ecoret, Xavier", bib[:py03][:author].to_s)
@@ -35,7 +32,7 @@ module BibTeX
       assert_equal('2003', bib[:py03][:year])
       assert_equal(:article, bib[:key03].type)
       assert_equal('A {bunch {of} braces {in}} title', bib[:key03][:title])
-      #TODO missing assertions
+      # TODO: missing assertions
     end
 
     # def test_errors
@@ -44,7 +41,7 @@ module BibTeX
     # end
 
     def test_bibdesk
-      bib = BibTeX::Bibliography.open(Test.fixtures(:bibdesk), :debug => false)
+      bib = BibTeX::Bibliography.open(Test.fixtures(:bibdesk), debug: false)
       assert_equal 3, bib.length
       assert_equal 'rails', bib[0].key
       assert_equal '2010-08-05 10:06:32 +0200', bib[:dragon]['date-modified']
@@ -77,7 +74,7 @@ module BibTeX
 
     def test_parse
       bib = BibTeX::Bibliography.new
-      bib.add(BibTeX::Element.parse(%q( @string{ pragprog = "The Pragmatic Bookshelf" } )))
+      bib.add(BibTeX::Element.parse(' @string{ pragprog = "The Pragmatic Bookshelf" } '))
       bib.add(BibTeX::Element.parse(<<-END))
       @book{rails,
         address = {Raleigh, North Carolina},
@@ -95,7 +92,7 @@ module BibTeX
       assert_equal(2, bib.length)
       refute_nil(bib[:rails])
       bib.replace_strings
-			assert_equal 'The Pragmatic Bookshelf', bib['rails'].publisher
+      assert_equal 'The Pragmatic Bookshelf', bib['rails'].publisher
     end
 
     def test_logger_can_be_assigned
@@ -121,7 +118,5 @@ EOF
 EOF
       end
     end
-
   end
-
 end