marc 1.1.1 → 1.2.0

data/test/tc_parsers.rb

@@ -1,180 +1,154 @@
-require 'test/unit'
-require 'marc'
+require "test/unit"
+require "marc"
+require "warning"
 
 class ParsersTest < Test::Unit::TestCase
+  LOADABLE_PARSERS = {
+    libxml: "xml",
+    nokogiri: "nokogiri",
+  }
+
+  @@parsers = LOADABLE_PARSERS.keys.each_with_object({}) do |label, h|
+    begin
+      require LOADABLE_PARSERS[label]
+      h[label] = true
+    rescue LoadError
+      warn "#{label} unavailable: skipping its tests"
+    end
+  end
+
+  def self.jstax_available?
+    require "java"
+    java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
+    true
+  rescue LoadError, java.lang.ClassNotFoundException
+    warn "jstax unavailable: skipping its tests"
+    false
+  end
+
+  @@parsers[:jstax] = jstax_available?
+
   def test_parser_default
     assert_equal("rexml", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml')
+    reader = MARC::XMLReader.new("test/one.xml")
     assert_kind_of(REXML::Parsers::PullParser, reader.parser)
   end
-  
+
   def test_set_nokogiri
-    begin
-      require 'nokogiri'
-      assert_equal("rexml", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-      reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_NOKOGIRI)
-      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
-      assert_equal("rexml", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml', :parser=>'nokogiri')
-      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
-      assert_equal("rexml", MARC::XMLReader.parser)      
-      MARC::XMLReader.parser=MARC::XMLReader::USE_NOKOGIRI
-      assert_equal("nokogiri", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
-      MARC::XMLReader.parser="nokogiri"
-      assert_equal("nokogiri", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)      
-    rescue LoadError
-      puts "\nNokogiri not available, skipping 'test_set_nokogiri'.\n"
-    end
+    return unless @@parsers[:nokogiri]
+    assert_equal("rexml", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(REXML::Parsers::PullParser, reader.parser)
+    reader = MARC::XMLReader.new("test/one.xml", parser: MARC::XMLReader::USE_NOKOGIRI)
+    assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
+    assert_equal("rexml", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml", parser: "nokogiri")
+    assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
+    assert_equal("rexml", MARC::XMLReader.parser)
+    MARC::XMLReader.parser = MARC::XMLReader::USE_NOKOGIRI
+    assert_equal("nokogiri", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
+    MARC::XMLReader.parser = "nokogiri"
+    assert_equal("nokogiri", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
   end
-  
-  def test_set_jrexml
-    if defined? JRUBY_VERSION
-      begin
-        require 'jrexml'
-        reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_JREXML)
-        assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-        assert_equal("rexml", MARC::XMLReader.parser)
-        reader = MARC::XMLReader.new('test/one.xml', :parser=>'jrexml')
-        assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-        assert_equal("rexml", MARC::XMLReader.parser)      
-        MARC::XMLReader.parser=MARC::XMLReader::USE_JREXML
-        assert_equal("jrexml", MARC::XMLReader.parser)
-        reader = MARC::XMLReader.new('test/one.xml')
-        assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-        MARC::XMLReader.parser="jrexml"
-        assert_equal("jrexml", MARC::XMLReader.parser)
-        reader = MARC::XMLReader.new('test/one.xml')
-        assert_kind_of(REXML::Parsers::PullParser, reader.parser)      
-      rescue LoadError
-        puts "\njrexml not available, skipping 'test_set_jrexml'.\n"
-      end
-    else
-      puts "\nTest not being run from JRuby, skipping 'test_set_jrexml'.\n"
-    end
-  end  
-  
-def test_set_jstax
-  if defined? JRUBY_VERSION
-    begin
-      assert_equal("rexml", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-    
-      reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_JSTAX)
-      assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
-      assert_equal("rexml", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml', :parser=>'jstax')
-      assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
-      assert_equal("rexml", MARC::XMLReader.parser)      
-      MARC::XMLReader.parser=MARC::XMLReader::USE_JSTAX
-      assert_equal("jstax", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
-      MARC::XMLReader.parser="jstax"
-      assert_equal("jstax", MARC::XMLReader.parser)
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
-    rescue java.lang.ClassNotFoundException
-      puts "\njavax.xml.stream not available, skipping 'test_set_jstax'.\n"
-    end
-  else
-    puts "\nTest not being run from JRuby, skipping 'test_set_jstax'.\n"
+
+  def test_set_jstax
+    return unless @@parsers[:jstax]
+    assert_equal("rexml", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(REXML::Parsers::PullParser, reader.parser)
+
+    reader = MARC::XMLReader.new("test/one.xml", parser: MARC::XMLReader::USE_JSTAX)
+    assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
+    assert_equal("rexml", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml", parser: "jstax")
+    assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
+    assert_equal("rexml", MARC::XMLReader.parser)
+    MARC::XMLReader.parser = MARC::XMLReader::USE_JSTAX
+    assert_equal("jstax", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
+    MARC::XMLReader.parser = "jstax"
+    assert_equal("jstax", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl, reader.parser)
   end
-end  
-  
+
   def test_set_rexml
-    reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_REXML)
+    reader = MARC::XMLReader.new("test/one.xml", parser: MARC::XMLReader::USE_REXML)
     assert_kind_of(REXML::Parsers::PullParser, reader.parser)
     assert_equal("rexml", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml', :parser=>'rexml')
+    reader = MARC::XMLReader.new("test/one.xml", parser: "rexml")
     assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-    assert_equal("rexml", MARC::XMLReader.parser)      
-    MARC::XMLReader.parser=MARC::XMLReader::USE_REXML
     assert_equal("rexml", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml')
+    MARC::XMLReader.parser = MARC::XMLReader::USE_REXML
+    assert_equal("rexml", MARC::XMLReader.parser)
+    reader = MARC::XMLReader.new("test/one.xml")
     assert_kind_of(REXML::Parsers::PullParser, reader.parser)
-    MARC::XMLReader.parser="rexml"
+    MARC::XMLReader.parser = "rexml"
     assert_equal("rexml", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml')
-    assert_kind_of(REXML::Parsers::PullParser, reader.parser)    
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(REXML::Parsers::PullParser, reader.parser)
   end
-  
+
   def test_set_magic
     best = choose_best_available_parser
     magic_parser = best[:parser]
-    puts "\nTesting 'test_set_magic' for parser: #{magic_parser}"
-    reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_BEST_AVAILABLE)
+    reader = MARC::XMLReader.new("test/one.xml", parser: MARC::XMLReader::USE_BEST_AVAILABLE)
     assert_kind_of(magic_parser, reader.parser)
     assert_equal("rexml", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml', :parser=>'magic')
+    reader = MARC::XMLReader.new("test/one.xml", parser: "magic")
     assert_kind_of(magic_parser, reader.parser)
-    assert_equal("rexml", MARC::XMLReader.parser)      
-    MARC::XMLReader.parser=MARC::XMLReader::USE_BEST_AVAILABLE
+    assert_equal("rexml", MARC::XMLReader.parser)
+    MARC::XMLReader.parser = MARC::XMLReader::USE_BEST_AVAILABLE
     assert_equal("magic", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml')
+    reader = MARC::XMLReader.new("test/one.xml")
     assert_kind_of(magic_parser, reader.parser)
-    MARC::XMLReader.parser="magic"
+    MARC::XMLReader.parser = "magic"
     assert_equal("magic", MARC::XMLReader.parser)
-    reader = MARC::XMLReader.new('test/one.xml')
-    assert_kind_of(magic_parser, reader.parser)    
-  end  
-  
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(magic_parser, reader.parser)
+  end
+
   def test_parser_set_convenience_methods
     best = choose_best_available_parser
     parser = best[:parser]
     parser_name = best[:parser_name]
     assert_equal(parser_name, MARC::XMLReader.best_available)
     MARC::XMLReader.best_available!
-    reader = MARC::XMLReader.new('test/one.xml')
+    reader = MARC::XMLReader.new("test/one.xml")
     assert_kind_of(parser, reader.parser)
     MARC::XMLReader.rexml!
-    reader = MARC::XMLReader.new('test/one.xml')
-    assert_kind_of(REXML::Parsers::PullParser, reader.parser)   
-    if parser_name == 'nokogiri'
+    reader = MARC::XMLReader.new("test/one.xml")
+    assert_kind_of(REXML::Parsers::PullParser, reader.parser)
+    if parser_name == "nokogiri"
       MARC::XMLReader.nokogiri!
-      reader = MARC::XMLReader.new('test/one.xml')
-      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)   
-    else
-      puts "\nNokogiri not loaded, skipping convenience method test.\n"
-    end
-    if defined? JRUBY_VERSION
-      begin
-        require 'jrexml'    
-        MARC::XMLReader.jrexml!
-        reader = MARC::XMLReader.new('test/one.xml')
-        assert_kind_of(REXML::Parsers::PullParser, reader.parser) 
-      rescue LoadError
-        puts "\njrexml not available, skipping convenience method test.\n"
-      end
-    else
-      puts "\nTest not being run from JRuby, skipping jrexml convenience method test.\n"
+      reader = MARC::XMLReader.new("test/one.xml")
+      assert_kind_of(Nokogiri::XML::SAX::Parser, reader.parser)
     end
   end
-    
+
   def teardown
-    MARC::XMLReader.parser=MARC::XMLReader::USE_REXML
+    MARC::XMLReader.parser = MARC::XMLReader::USE_REXML
   end
-  
+
   def choose_best_available_parser
     parser_name = nil
     parser = nil
-    unless parser    
+    unless parser
       begin
-        require 'nokogiri'
-        parser_name = 'nokogiri'
+        require "nokogiri"
+        parser_name = "nokogiri"
         parser = Nokogiri::XML::SAX::Parser
       rescue LoadError
       end
     end
     unless parser
       if defined? JRUBY_VERSION
-        require 'java'
+        require "java"
         begin
           java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
           parser_name = "jstax"
@@ -186,27 +160,17 @@ end
     unless parser
       if !defined? JRUBY_VERSION
         begin
-          require 'xml'
-          parser_name = 'libxml'
+          require "xml"
+          parser_name = "libxml"
           parser = LibXML::XML::Reader
         rescue LoadError
         end
-      else
-        if defined? JRUBY_VERSION
-          begin
-            require 'jrexml'
-            parser_name = 'jrexml'
-            parser = REXML::Parsers::PullParser
-          rescue LoadError
-          end        
-        end
       end
       unless parser
         parser = REXML::Parsers::PullParser
-        parser_name = 'rexml'
+        parser_name = "rexml"
       end
-    end    
-    return {:parser=>parser, :parser_name=>parser_name}
+    end
+    {parser: parser, parser_name: parser_name}
   end
-  
-end
+end

data/test/tc_reader.rb

@@ -1,92 +1,92 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'marc'
+require "test/unit"
+require "marc"
 
 class ReaderTest < Test::Unit::TestCase
-
   def test_batch
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     count = 0
     reader.each { count += 1 }
     assert_equal(count, 10)
   end
 
   def test_loose
-    reader = MARC::ForgivingReader.new('test/batch.dat')
+    reader = MARC::ForgivingReader.new("test/batch.dat")
     count = 0
     reader.each { count += 1 }
     assert_equal(10, count)
   end
-  
+
   def test_loose_utf8
-    # This isn't actually a corrupt file, but it is utf8, 
+    # This isn't actually a corrupt file, but it is utf8,
     # and I have some reason to believe forgiving reader isn't
-    # working properly with UTF8 in ruby 1.9, so testing it. 
-    reader = MARC::ForgivingReader.new('test/utf8.marc')
+    # working properly with UTF8 in ruby 1.9, so testing it.
+    reader = MARC::ForgivingReader.new("test/utf8.marc")
     count = 0
     reader.each { count += 1 }
     assert_equal(1, count)
   end
-  
+
   def test_loose_unimarc
-    # Unimarc might use a different record seperator? Let's make sure it works. 
-    reader = MARC::Reader.new(File.open('test/cp866_unimarc.marc', 'r:cp866'))
+    # Unimarc might use a different record seperator? Let's make sure it works.
+    reader = MARC::Reader.new(File.open("test/cp866_unimarc.marc", "r:cp866"))
     count = 0
-    reader.each {|a| count += 1 }
+    reader.each { |a| count += 1 }
     assert_equal(1, count)
   end
 
   def test_non_numeric_tags
-    reader = MARC::Reader.new('test/non-numeric.dat')
+    reader = MARC::Reader.new("test/non-numeric.dat")
     count = 0
     record = nil
-    reader.each do | rec |
+    reader.each do |rec|
       count += 1
       record = rec
     end
     assert_equal(1, count)
-    assert_equal('9780061317842', record['ISB']['a'])
-    assert_equal('1', record['LOC']['9'])
+    assert_equal("9780061317842", record["ISB"]["a"])
+    assert_equal("1", record["LOC"]["9"])
   end
 
   def test_bad_marc
-    reader = MARC::Reader.new('test/tc_reader.rb')
-    assert_raises(MARC::Exception) {reader.entries[0]}
+    reader = MARC::Reader.new("test/tc_reader.rb")
+    assert_raises(MARC::Exception) { reader.entries[0] }
   end
 
   def test_search
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     records = reader.find_all { |r| r =~ /Perl/ }
     assert_equal(10, records.length)
 
-    reader = MARC::Reader.new('test/batch.dat')
-    records = reader.find_all { |r| r['245'] =~ /Perl/ }
+    reader = MARC::Reader.new("test/batch.dat")
+    records = reader.find_all { |r| r["245"] =~ /Perl/ }
     assert_equal(10, records.length)
 
-    reader = MARC::Reader.new('test/batch.dat')
-    records = reader.find_all { |r| r['245']['a'] =~ /Perl/ }
+    reader = MARC::Reader.new("test/batch.dat")
+    records = reader.find_all { |r| r["245"]["a"] =~ /Perl/ }
     assert_equal(10, records.length)
 
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     records = reader.find_all { |r| r =~ /Foo/ }
     assert_equal(0, records.length)
   end
-  
+
   def test_binary_enumerator
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     iter = reader.each
     r = iter.next
     assert_instance_of(MARC::Record, r)
-    9.times {iter.next} # total of ten records
-    assert_raises(StopIteration) { iter.next }  
+    9.times { iter.next } # total of ten records
+    assert_raises(StopIteration) { iter.next }
   end
 
   def test_each_raw
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     count = 0
     raw = nil
-    reader.each_raw { |r| count += 1; raw = r }
+    reader.each_raw { |r|
+      count += 1
+      raw = r
+    }
     assert_equal(count, 10)
     assert_instance_of(String, raw)
 
@@ -95,7 +95,7 @@ class ReaderTest < Test::Unit::TestCase
   end
 
   def test_each_raw_enum
-    reader = MARC::Reader.new('test/batch.dat')
+    reader = MARC::Reader.new("test/batch.dat")
     enum = reader.each_raw
     r = enum.next
     assert_instance_of(String, r)
@@ -103,8 +103,7 @@ class ReaderTest < Test::Unit::TestCase
     record = MARC::Reader.decode(r)
     assert_instance_of(MARC::Record, record)
 
-    9.times {enum.next} # total of ten records
+    9.times { enum.next } # total of ten records
     assert_raises(StopIteration) { enum.next }
   end
-
 end