marc 1.0.4 → 1.2.0

data/test/tc_writer.rb

@@ -1,142 +1,135 @@
-require 'test/unit'
-require 'marc'
+require "test/unit"
+require "marc"
 
-require 'stringio'
+require "stringio"
 
 class WriterTest < Test::Unit::TestCase
+  def test_writer
+    writer = MARC::Writer.new("test/writer.dat")
+    record = MARC::Record.new
+    record.append(MARC::DataField.new("245", "0", "1", ["a", "foo"]))
+    writer.write(record)
+    writer.close
 
-    def test_writer
-        writer = MARC::Writer.new('test/writer.dat')
-        record = MARC::Record.new()
-        record.append(MARC::DataField.new('245', '0', '1', ['a', 'foo']))
-        writer.write(record)
-        writer.close()
-
-        # read it back to make sure
-        reader = MARC::Reader.new('test/writer.dat')
-        records = reader.entries()
-        assert_equal(records.length(), 1)
-        assert_equal(records[0], record)
-
-        # cleanup
-        File.unlink('test/writer.dat')
-    end
+    # read it back to make sure
+    reader = MARC::Reader.new("test/writer.dat")
+    records = reader.entries
+    assert_equal(records.length, 1)
+    assert_equal(records[0], record)
 
-    # Only in ruby 1.9
-    if "".respond_to?(:encoding)
-      def test_writer_bad_encoding
-        writer = MARC::Writer.new('test/writer.dat')
+    # cleanup
+    File.unlink("test/writer.dat")
+  end
 
+  # Only in ruby 1.9
+  if "".respond_to?(:encoding)
+    def test_writer_bad_encoding
+      writer = MARC::Writer.new("test/writer.dat")
 
-        # MARC::Writer should just happily write out whatever bytes you give it, even
-        # mixing encodings that can't be mixed. We ran into an actual example mixing
-        # MARC8 (tagged ruby binary) and UTF8, we want it to be written out. 
+      # MARC::Writer should just happily write out whatever bytes you give it, even
+      # mixing encodings that can't be mixed. We ran into an actual example mixing
+      # MARC8 (tagged ruby binary) and UTF8, we want it to be written out.
 
-        record = MARC::Record.new
+      record = MARC::Record.new
 
-        record.append MARC::DataField.new('700', '0', ' ', ['a', "Nhouy Abhay,".force_encoding("BINARY")], ["c", "Th\xE5ao,".force_encoding("BINARY")], ["d", "1909-"])
-        record.append MARC::DataField.new('700', '0', ' ', ['a', "Somchin P\xF8\xE5o. Ngin,".force_encoding("BINARY")])
+      record.append MARC::DataField.new("700", "0", " ", ["a", "Nhouy Abhay,".force_encoding("BINARY")], ["c", "Th\xE5ao,".force_encoding("BINARY")], ["d", "1909-"])
+      record.append MARC::DataField.new("700", "0", " ", ["a", "Somchin P\xF8\xE5o. Ngin,".force_encoding("BINARY")])
 
-        record.append MARC::DataField.new('100', '0', '0', ['a', "\xE5angkham. ".force_encoding("BINARY")])
-        record.append MARC::DataField.new('245', '1', '0', ['b', "chef-d'oeuvre de la litt\xE2erature lao".force_encoding("BINARY")])
+      record.append MARC::DataField.new("100", "0", "0", ["a", "\xE5angkham. ".force_encoding("BINARY")])
+      record.append MARC::DataField.new("245", "1", "0", ["b", "chef-d'oeuvre de la litt\xE2erature lao".force_encoding("BINARY")])
 
-        # One in UTF8 and marked 
-        record.append MARC::DataField.new('999', '0', '1', ['a', "chef-d'ocuvre de la littU+FFC3\U+FFA9rature".force_encoding("UTF-8")])
+      # One in UTF8 and marked
+      record.append MARC::DataField.new("999", "0", "1", ["a", "chef-d'ocuvre de la littU+FFC3\U+FFA9rature".force_encoding("UTF-8")])
 
-        writer.write(record)
-        writer.close
+      writer.write(record)
+      writer.close
+    ensure
+      File.unlink("test/writer.dat")
+    end
+  end
 
-      ensure 
-          File.unlink('test/writer.dat')
-      end
+  def test_write_too_long_iso2709
+    too_long_record = MARC::Record.new
+    1.upto(1001) do
+      too_long_record.append MARC::DataField.new("500", " ", " ", ["a", "A really long record.1234567890123456789012345678901234567890123456789012345678901234567890123456789"])
     end
 
-    def test_write_too_long_iso2709
-      too_long_record = MARC::Record.new
-      1.upto(1001) do
-        too_long_record.append MARC::DataField.new("500", ' ', ' ', ['a', 'A really long record.1234567890123456789012345678901234567890123456789012345678901234567890123456789'])
-      end
+    wbuffer = StringIO.new("", "w")
+    writer = MARC::Writer.new(wbuffer)
+    writer.allow_oversized = true
 
-      wbuffer = StringIO.new("", "w")
-      writer = MARC::Writer.new(wbuffer)
-      writer.allow_oversized = true
+    writer.write(too_long_record)
+    writer.close
 
-      writer.write(too_long_record)
-      writer.close
+    assert_equal "00000", wbuffer.string.slice(0, 5), "zero'd out length bytes when too long"
 
-      assert_equal "00000", wbuffer.string.slice(0, 5), "zero'd out length bytes when too long"
+    rbuffer = StringIO.new(wbuffer.string.dup)
 
-      rbuffer = StringIO.new(wbuffer.string.dup)
+    # Regular reader won't read our illegal record.
+    # assert_raise(NoMethodError) do
+    #  reader = MARC::Reader.new(rbuffer)
+    #  reader.first
+    # end
 
-      # Regular reader won't read our illegal record.
-      #assert_raise(NoMethodError) do
-      #  reader = MARC::Reader.new(rbuffer)
-      #  reader.first
-      #end
+    # Forgiving reader will, round trippable
+    new_record = MARC::Reader.decode(rbuffer.string, forgiving: true)
+    assert_equal too_long_record, new_record, "Too long record round-trippable with forgiving mode"
 
-      # Forgiving reader will, round trippable
-      new_record = MARC::Reader.decode(rbuffer.string, :forgiving => true)      
-      assert_equal too_long_record, new_record, "Too long record round-trippable with forgiving mode"
+    # Test in the middle of a MARC file
+    good_record = MARC::Record.new
+    good_record.append MARC::DataField.new("500", " ", " ", ["a", "A short record"])
+    wbuffer = StringIO.new("", "w")
+    writer = MARC::Writer.new(wbuffer)
+    writer.allow_oversized = true
 
-      # Test in the middle of a MARC file
-      good_record = MARC::Record.new
-      good_record.append MARC::DataField.new("500", ' ', ' ', ['a', 'A short record'])
-      wbuffer = StringIO.new("", "w")
-      writer = MARC::Writer.new(wbuffer)
-      writer.allow_oversized = true
+    writer.write(good_record)
+    writer.write(too_long_record)
+    writer.write(good_record)
 
-      writer.write(good_record)
-      writer.write(too_long_record)
-      writer.write(good_record)
+    rbuffer = StringIO.new(wbuffer.string.dup)
+    reader = MARC::ForgivingReader.new(rbuffer)
+    records = reader.to_a
 
-      rbuffer = StringIO.new(wbuffer.string.dup)
-      reader  = MARC::ForgivingReader.new(rbuffer)
-      records = reader.to_a
+    assert_equal 3, records.length
+    assert_equal good_record, records[0]
+    assert_equal good_record, records[2]
+    assert_equal too_long_record, records[1]
+  end
 
-      assert_equal 3, records.length
-      assert_equal good_record, records[0]
-      assert_equal good_record, records[2]
-      assert_equal too_long_record, records[1]
+  def test_raises_on_too_long_if_configured
+    too_long_record = MARC::Record.new
+    1.upto(1001) do
+      too_long_record.append MARC::DataField.new("500", " ", " ", ["a", "A really long record.1234567890123456789012345678901234567890123456789012345678901234567890123456789"])
     end
 
-    def test_raises_on_too_long_if_configured
-      too_long_record = MARC::Record.new
-      1.upto(1001) do
-        too_long_record.append MARC::DataField.new("500", ' ', ' ', ['a', 'A really long record.1234567890123456789012345678901234567890123456789012345678901234567890123456789'])
-      end
-
-      wbuffer = StringIO.new("", "w")
-      writer = MARC::Writer.new(wbuffer)
-
-      assert_raise(MARC::Exception) do
-        writer.write too_long_record
-      end
+    wbuffer = StringIO.new("", "w")
+    writer = MARC::Writer.new(wbuffer)
 
+    assert_raise(MARC::Exception) do
+      writer.write too_long_record
     end
+  end
 
-    
-    def test_forgiving_writer
-      marc = "00305cam a2200133 a 4500001000700000003000900007005001700016008004100033008004100074035002500115245001700140909001000157909000400167\036635145\036UK-BiLMS\03620060329173705.0\036s1982iieng6                  000 0 eng||\036060116|||||||||xxk                 eng||\036  \037a(UK-BiLMS)M0017366ZW\03600\037aTest record.\036  \037aa\037b\037c\036\037b0\036\035\000"
-      rec = MARC::Record.new_from_marc(marc)
-      assert_nothing_raised do 
-        rec.to_marc
-      end
+  def test_forgiving_writer
+    marc = "00305cam a2200133 a 4500001000700000003000900007005001700016008004100033008004100074035002500115245001700140909001000157909000400167\036635145\036UK-BiLMS\03620060329173705.0\036s1982iieng6                  000 0 eng||\036060116|||||||||xxk                 eng||\036  \037a(UK-BiLMS)M0017366ZW\03600\037aTest record.\036  \037aa\037b\037c\036\037b0\036\035\000"
+    rec = MARC::Record.new_from_marc(marc)
+    assert_nothing_raised do
+      rec.to_marc
     end
+  end
 
-    def test_unicode_roundtrip
-      record = MARC::Reader.new('test/utf8.marc', :external_encoding => "UTF-8").first
-      
-      writer = MARC::Writer.new('test/writer.dat')      
-      writer.write(record)      
-      writer.close      
-      
-      read_back_record = MARC::Reader.new('test/writer.dat', :external_encoding => "UTF-8").first
-
-      # Make sure the one we wrote out then read in again
-      # is the same as the one we read the first time
-      # Looks like "==" is over-ridden to do that. Don't ever change, #==
-      assert_equal record, read_back_record, "Round-tripped record must equal original record"
-    end
-    
+  def test_unicode_roundtrip
+    record = MARC::Reader.new("test/utf8.marc", external_encoding: "UTF-8").first
+
+    writer = MARC::Writer.new("test/writer.dat")
+    writer.write(record)
+    writer.close
+
+    read_back_record = MARC::Reader.new("test/writer.dat", external_encoding: "UTF-8").first
 
+    # Make sure the one we wrote out then read in again
+    # is the same as the one we read the first time
+    # Looks like "==" is over-ridden to do that. Don't ever change, #==
+    assert_equal record, read_back_record, "Round-tripped record must equal original record"
+  end
 end

data/test/tc_xml.rb

@@ -1,28 +1,26 @@
-require 'test/unit'
-require 'marc'
-require 'stringio'
+require "test/unit"
+require "marc"
+require "stringio"
+require "warning"
 
 class XMLTest < Test::Unit::TestCase
+  Warning.ignore(/is deprecated and will be removed in a future version of ruby-marc/)
+  Warning.ignore(/setting Encoding.default_internal/)
   def setup
     @parsers = [:rexml]
     begin
-      require 'nokogiri'
+      require "nokogiri"
       @parsers << :nokogiri
     rescue LoadError
     end
     unless defined? JRUBY_VERSION
       begin
-        require 'xml'
+        require "xml"
         @parsers << :libxml
       rescue LoadError
       end
     end
     if defined? JRUBY_VERSION
-      begin
-        require 'jrexml'
-        @parsers << :jrexml
-      rescue LoadError
-      end
       begin
         java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
         @parsers << :jstax
@@ -31,151 +29,165 @@ class XMLTest < Test::Unit::TestCase
     end
   end
 
-
-  def test_xml_entities    
-    @parsers.each do | parser |
-      puts "\nRunning test_xml_entities with: #{parser}.\n"
+  def test_xml_entities
+    @parsers.each do |parser|
       xml_entities_test(parser)
     end
   end
-  
+
   def xml_entities_test(parser)
     r1 = MARC::Record.new
-    r1 << MARC::DataField.new('245', '0', '0', ['a', 'foo & bar & baz'])
+    r1 << MARC::DataField.new("245", "0", "0", ["a", "foo & bar & baz"])
     xml = r1.to_xml.to_s
-    assert_match /foo &amp; bar &amp; baz/, xml
+    assert_match(/foo &amp; bar &amp; baz/, xml, "Failed with parser '#{parser}'")
 
-    reader = MARC::XMLReader.new(StringIO.new(xml), :parser=>parser)
+    reader = MARC::XMLReader.new(StringIO.new(xml), parser: parser)
     r2 = reader.entries[0]
-    assert_equal 'foo & bar & baz', r2['245']['a']    
+    assert_equal("foo & bar & baz", r2["245"]["a"], "Failed with parser '#{parser}'")
   end
-  
+
   def test_batch
-    @parsers.each do | parser |
-      puts "\nRunning test_batch with: #{parser}.\n"
+    @parsers.each do |parser|
       batch_test(parser)
-    end    
+    end
   end
-  
+
   def batch_test(parser)
-    reader = MARC::XMLReader.new('test/batch.xml', :parser=>parser)
+    reader = MARC::XMLReader.new("test/batch.xml", parser: parser)
     count = 0
-    for record in reader
+    reader.each do |record|
       count += 1
-      assert_instance_of(MARC::Record, record)
+      assert_instance_of(MARC::Record, record, "Failed with parser '#{parser}'")
     end
-    assert_equal(count, 2)
+    assert_equal(count, 2, "Failed with parser '#{parser}'")
   end
-  
+
   def test_read_string
-    @parsers.each do | parser |
-      puts "\nRunning test_read_string with: #{parser}.\n"
+    @parsers.each do |parser|
       read_string_test(parser)
-    end  
+    end
   end
 
   def read_string_test(parser)
-    xml = File.new('test/batch.xml').read
-    reader = MARC::XMLReader.new(StringIO.new(xml), :parser=>parser)
-    assert_equal 2, reader.entries.length
+    xml = File.new("test/batch.xml").read
+    reader = MARC::XMLReader.new(StringIO.new(xml), parser: parser)
+    assert_equal 2, reader.entries.length, "Failed with parser '#{parser}'"
   end
-  
+
   def test_non_numeric_fields
-    @parsers.each do | parser |
-      puts "\nRunning test_non_numeric_fields with: #{parser}.\n"
+    @parsers.each do |parser|
       non_numeric_fields_test(parser)
     end
   end
-    
+
   def non_numeric_fields_test(parser)
-    reader = MARC::XMLReader.new('test/non-numeric.xml', :parser=>parser)
-      count = 0
-      record = nil
-      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'])
+    reader = MARC::XMLReader.new("test/non-numeric.xml", parser: parser)
+    count = 0
+    record = nil
+    reader.each do |rec|
+      count += 1
+      record = rec
     end
+    assert_equal(1, count, "Failed with parser '#{parser}'")
+    assert_equal("9780061317842", record["ISB"]["a"], "Failed with parser '#{parser}'")
+    assert_equal("1", record["LOC"]["9"], "Failed with parser '#{parser}'")
+  end
 
   def test_read_no_leading_zero_write_leading_zero
-    @parsers.each do | parser |
-      puts "\nRunning test_read_no_leading_zero_write_leading_zero with: #{parser}.\n"
+    @parsers.each do |parser|
       read_no_leading_zero_write_leading_zero_test(parser)
-    end    
+    end
   end
-  
+
   def read_no_leading_zero_write_leading_zero_test(parser)
-    reader = MARC::XMLReader.new('test/no-leading-zero.xml', :parser=>parser)
+    reader = MARC::XMLReader.new("test/no-leading-zero.xml", parser: parser)
     record = reader.to_a[0]
-    assert_equal("042 zz $a dc ", record['042'].to_s)
+    assert_equal("042 zz $a dc ", record["042"].to_s, "Failed with parser '#{parser}'")
   end
 
   def test_leader_from_xml
-    @parsers.each do | parser |
-      puts "\nRunning test_leader_from_xml with: #{parser}.\n"
+    @parsers.each do |parser|
       leader_from_xml_test(parser)
     end
-  end    
+  end
 
   def leader_from_xml_test(parser)
-    reader = MARC::XMLReader.new('test/one.xml', :parser=>parser)
+    reader = MARC::XMLReader.new("test/one.xml", parser: parser)
     record = reader.entries[0]
-    assert_equal '     njm a22     uu 4500', record.leader
+    assert_equal "     njm a22     uu 4500", record.leader, "Failed with parser '#{parser}'"
+
     # serializing as MARC should populate the record length and directory offset
     record = MARC::Record.new_from_marc(record.to_marc)
-    assert_equal '00734njm a2200217uu 4500', record.leader
+    assert_equal "00734njm a2200217uu 4500", record.leader, "Failed with parser '#{parser}'"
   end
-  
+
   def test_read_write
-    @parsers.each do | parser |
-      puts "\nRunning test_read_write with: #{parser}.\n"
+    @parsers.each do |parser|
       read_write_test(parser)
     end
-  end    
+  end
 
   def read_write_test(parser)
     record1 = MARC::Record.new
-    record1.leader =  '00925njm  22002777a 4500'
-    record1.append MARC::ControlField.new('007', 'sdubumennmplu')
-    record1.append MARC::DataField.new('245', '0', '4', 
-      ['a', 'The Great Ray Charles'], ['h', '[sound recording].'])
+    record1.leader = "00925njm  22002777a 4500"
+    record1.append MARC::ControlField.new("007", "sdubumennmplu")
+    record1.append MARC::DataField.new("245", "0", "4",
+      ["a", "The Great Ray Charles"], ["h", "[sound recording]."])
+    record1.append MARC::DataField.new("998", " ", " ",
+      ["^", "Valid local subfield"])
 
-    writer = MARC::XMLWriter.new('test/test.xml', :stylesheet => 'style.xsl')
+    writer = MARC::XMLWriter.new("test/test.xml", stylesheet: "style.xsl")
     writer.write(record1)
     writer.close
 
-    xml = File.read('test/test.xml')
-    assert_match /<controlfield tag='007'>sdubumennmplu<\/controlfield>/, xml
-    assert_match /<\?xml-stylesheet type="text\/xsl" href="style.xsl"\?>/, xml
+    xml = File.read("test/test.xml")
+    assert_match(/<controlfield tag='007'>sdubumennmplu<\/controlfield>/, xml, "Failed with parser '#{parser}'")
+    assert_match(/<\?xml-stylesheet type="text\/xsl" href="style.xsl"\?>/, xml, "Failed with parser '#{parser}'")
 
-    reader = MARC::XMLReader.new('test/test.xml', :parser=>parser)
+    reader = MARC::XMLReader.new("test/test.xml", parser: parser)
     record2 = reader.entries[0]
-    assert_equal(record1, record2)
-
-    File.unlink('test/test.xml')
+    assert_equal(record1, record2, "Failed with parser '#{parser}'")
+  ensure
+    File.unlink("test/test.xml")
   end
-  
+
   def test_xml_enumerator
-    @parsers.each do | parser |
-      puts "\nRunning test_xml_enumerator with: #{parser}.\n"
+    @parsers.each do |parser|
       xml_enumerator_test(parser)
     end
   end
-  
-  
+
   def xml_enumerator_test(parser)
     # confusingly, test/batch.xml only has two records, not 10 like batch.dat
-    reader = MARC::XMLReader.new('test/batch.xml', :parser=>parser)
+    reader = MARC::XMLReader.new("test/batch.xml", parser: parser)
     iter = reader.each
     r = iter.next
-    assert_instance_of(MARC::Record, r)
+    assert_instance_of(MARC::Record, r, "Failed with parser '#{parser}'")
     iter.next # total of two records
-    assert_raises(StopIteration) { iter.next }  
+    assert_raise(StopIteration, "Failed with parser '#{parser}'") { iter.next }
   end
-  
 
-end
+  def test_truncated_leader_roundtripping
+    record1 = MARC::Record.new
+    record1.leader = "00925njm  22002777a"
+
+    writer = MARC::XMLWriter.new("test/test.xml", stylesheet: "style.xsl")
+    writer.write(record1)
+    writer.close
 
+    reader = MARC::XMLReader.new("test/test.xml")
+    record2 = reader.entries[0]
+
+    assert_equal("00925njm  22002777a 4500", record2.leader)
+  ensure
+    File.unlink("test/test.xml")
+  end
+
+  def test_xml_weird_leader
+    @parsers.each do |parser|
+      reader = MARC::XMLReader.new("test/messed_up_leader.xml", parser: parser)
+      record = reader.first
+      assert_equal(record.leader, "01301nam a22003618< 4500", "Failed with parser '#{parser}'")
+    end
+  end
+end

data/test/tc_xml_error_handling.rb

@@ -1,22 +1,21 @@
-require 'test/unit'
-require 'marc'
+require "test/unit"
+require "marc"
 
 class BadXMLHandlingTestCase < Test::Unit::TestCase
-
   def test_nokogiri_bad_xml
     begin
-      require 'nokogiri'
+      require "nokogiri"
     rescue LoadError
       omit("nokogiri not installed, cannot test")
     end
-    omit("nokogiri (<1.10.2) under jruby doesn't support error handling: sparklemotion/nokogiri#1847") if RUBY_PLATFORM == 'java' && Gem::Version.new(Nokogiri::VERSION) < Gem::Version.new('1.10.2')
+    omit("nokogiri (<1.10.2) under jruby doesn't support error handling: sparklemotion/nokogiri#1847") if RUBY_PLATFORM == "java" && Gem::Version.new(Nokogiri::VERSION) < Gem::Version.new("1.10.2")
     count = 0
-    reader = MARC::XMLReader.new('test/three-records-second-bad.xml', :parser => :nokogiri)
+    reader = MARC::XMLReader.new("test/three-records-second-bad.xml", parser: :nokogiri)
     assert_raise MARC::XMLParseError do
       reader.each do |rec|
-        count += 1 if rec['260']
+        count += 1 if rec["260"]
       end
     end
-    assert_equal(1, count, 'should only be able to parse one record')
+    assert_equal(1, count, "should only be able to parse one record")
   end
 end

data/test/ts_marc.rb

@@ -4,11 +4,11 @@
 # not already installed one
 $LOAD_PATH.unshift("lib")
 
-require 'test/unit'
-require 'test/tc_subfield'
-require 'test/tc_datafield'
-require 'test/tc_controlfield'
-require 'test/tc_record'
-require 'test/tc_reader'
-require 'test/tc_writer'
-require 'test/tc_xml'
+require "test/unit"
+require "test/tc_subfield"
+require "test/tc_datafield"
+require "test/tc_controlfield"
+require "test/tc_record"
+require "test/tc_reader"
+require "test/tc_writer"
+require "test/tc_xml"