marc 1.1.1 → 1.2.0

data/test/tc_record.rb

@@ -1,157 +1,152 @@
-require 'test/unit'
-require 'marc'
-require 'xmlsimple'
-
- def xml_cmp a, b
-   eq_all_but_zero = Object.new.instance_eval do
-     def ==(other)
-       Integer(other) == 0 ? false : true
-     end
-     self
-   end
-   a = XmlSimple.xml_in(a.to_s, 'normalisespace' => eq_all_but_zero) 
-   b = XmlSimple.xml_in(b.to_s, 'normalisespace' => eq_all_but_zero) 
-   a == b
- end
-
-class TestRecord < Test::Unit::TestCase
-
-    def test_constructor
-        r = MARC::Record.new()
-        assert_equal(r.class, MARC::Record)
-    end
-
-    def test_xml
-      r = get_record()
-      doc = r.to_xml
-      assert_kind_of REXML::Element, doc
-      assert xml_cmp("<record xmlns='http://www.loc.gov/MARC21/slim'><leader>      Z   22        4500</leader><datafield tag='100' ind1='2' ind2='0'><subfield code='a'>Thomas, Dave</subfield></datafield><datafield tag='245' ind1='0' ind2='4'><subfield code='The Pragmatic Programmer'></subfield></datafield></record>", doc.to_s)
-    end
-
-    def test_append_field
-        r = get_record()
-        assert_equal(r.fields.length(), 2)
-    end
-
-    def test_iterator
-        r = get_record()
-        count = 0
-        r.each {|f| count += 1}
-        assert_equal(count,2)
-    end
-
-    def test_decode
-        raw = IO.read('test/one.dat')
-        r = MARC::Record::new_from_marc(raw)
-        assert_equal(r.class, MARC::Record)
-        assert_equal(r.leader, '00755cam  22002414a 4500')
-        assert_equal(r.fields.length(), 18)
-        assert_equal(r.find {|f| f.tag == '245'}.to_s,
-            '245 10 $a ActivePerl with ASP and ADO / $c Tobias Martinsson. ')
-    end
-
-    def test_decode_forgiving
-        raw = IO.read('test/one.dat')
-        r = MARC::Record::new_from_marc(raw, :forgiving => true)
-        assert_equal(r.class, MARC::Record)
-        assert_equal(r.leader, '00755cam  22002414a 4500')
-        assert_equal(r.fields.length(), 18)
-        assert_equal(r.find {|f| f.tag == '245'}.to_s,
-            '245 10 $a ActivePerl with ASP and ADO / $c Tobias Martinsson. ')
-    end
-
-    def test_encode
-        r1 = MARC::Record.new()
-        r1.append(MARC::DataField.new('100', '2', '0', ['a', 'Thomas, Dave']))
-        r1.append(MARC::DataField.new('245', '0', '0', ['a', 'Pragmatic Programmer']))
-        raw = r1.to_marc()
-        r2 = MARC::Record::new_from_marc(raw)
-        assert_equal(r1, r2)
-    end
-
-    def test_lookup_shorthand
-        r = get_record
-        assert_equal(r['100']['a'], 'Thomas, Dave')
-    end
-
-    def get_record
-        r = MARC::Record.new()
-        r.append(MARC::DataField.new('100', '2', '0', ['a', 'Thomas, Dave'])) 
-        r.append(MARC::DataField.new('245', '0', '4', ['The Pragmatic Programmer']))
-        return r
-    end
-    
-    def test_field_index
-      raw = IO.read('test/random_tag_order.dat')
-      r = MARC::Record.new_from_marc(raw)
-      assert_kind_of(Array, r.fields)
-      assert_kind_of(Array, r.tags)
-      assert_equal(['001','005','007','008','010','028','035','040','050','245','260','300','500','505','511','650','700','906','953','991'], r.tags.sort)
-      assert_kind_of(Array, r.fields('035'))
-      raw2 = IO.read('test/random_tag_order2.dat')
-      r2 = MARC::Record.new_from_marc(raw2)
-      assert_equal(6, r2.fields('500').length)     
-      # Test passing an array to Record#fields
-      assert_equal(3, r.fields(['500','505', '510', '511']).length) 
-      # Test passing a Range to Record#fields
-      assert_equal(9, r.fields(('001'..'099')).length)
-    end
-    
-    def test_field_index_order
-      raw = IO.read('test/random_tag_order.dat')
-      r = MARC::Record.new_from_marc(raw)      
-      notes = ['500','505','511']
-      r.fields(('500'..'599')).each do |f|
-        assert_equal(notes.pop, f.tag)
-      end
-      
-      
-      raw2 = IO.read('test/random_tag_order2.dat')
-      r2 = MARC::Record.new_from_marc(raw2)      
-      
-      fields = ['050','042','010','028','024','035','041','028','040','035','008','007','005','001']
-      r2.each_by_tag(('001'..'099')) do |f|
-        assert_equal(fields.pop, f.tag)
-      end      
-      
-      five_hundreds = r2.fields('500')
-      assert_equal(five_hundreds.first['a'], '"Contemporary blues" interpretations of previously released songs; written by Bob Dylan.')
-      assert_equal(five_hundreds.last['a'], 'Composer and program notes in container.')
+require "test/unit"
+require "marc"
+require "xmlsimple"
+
+def xml_cmp a, b
+  eq_all_but_zero = Object.new.instance_eval do
+    def ==(other)
+      !(Integer(other) == 0)
     end
 
+    self
+  end
+  a = XmlSimple.xml_in(a.to_s, "normalisespace" => eq_all_but_zero)
+  b = XmlSimple.xml_in(b.to_s, "normalisespace" => eq_all_but_zero)
+  a == b
+end
 
-    # Some tests for the internal FieldMap hash, normally
-    # an implementation detail, but things get tricky and we need
-    # tests to make sure we're good. Some of these you might
-    # change if you change FieldMap caching implementation or contract/API. 
-    def test_direct_change_dirties_fieldmap
-      # if we ask for #fields directly, and mutate it
-      # with it's own methods, does any cache update?
-      r = MARC::Record.new
-      assert r.fields('500').empty? 
-      r.fields.push MARC::DataField.new('500', ' ', ' ', ['a', 'notes'])
-      assert ! r.fields('500').empty?, "New 505 directly added to #fields is picked up"
-
-      # Do it again, make sure #[] works too
-      r = MARC::Record.new
-      assert r['500'].nil?
-      r.fields.push MARC::DataField.new('500', ' ', ' ', ['a', 'notes'])
-      assert r['500'], "New 505 directly added to #fields is picked up"
+class TestRecord < Test::Unit::TestCase
+  def test_constructor
+    r = MARC::Record.new
+    assert_equal(r.class, MARC::Record)
+  end
+
+  def test_xml
+    r = get_record
+    doc = r.to_xml
+    assert_kind_of REXML::Element, doc
+    assert xml_cmp("<record xmlns='http://www.loc.gov/MARC21/slim'><leader>      Z   22        4500</leader><datafield tag='100' ind1='2' ind2='0'><subfield code='a'>Thomas, Dave</subfield></datafield><datafield tag='245' ind1='0' ind2='4'><subfield code='The Pragmatic Programmer'></subfield></datafield></record>", doc.to_s)
+  end
+
+  def test_append_field
+    r = get_record
+    assert_equal(r.fields.length, 2)
+  end
+
+  def test_iterator
+    r = get_record
+    count = 0
+    r.each { |f| count += 1 }
+    assert_equal(count, 2)
+  end
+
+  def test_decode
+    raw = IO.read("test/one.dat")
+    r = MARC::Record.new_from_marc(raw)
+    assert_equal(r.class, MARC::Record)
+    assert_equal(r.leader, "00755cam  22002414a 4500")
+    assert_equal(r.fields.length, 18)
+    assert_equal(r.find { |f| f.tag == "245" }.to_s,
+      "245 10 $a ActivePerl with ASP and ADO / $c Tobias Martinsson. ")
+  end
+
+  def test_decode_forgiving
+    raw = IO.read("test/one.dat")
+    r = MARC::Record.new_from_marc(raw, forgiving: true)
+    assert_equal(r.class, MARC::Record)
+    assert_equal(r.leader, "00755cam  22002414a 4500")
+    assert_equal(r.fields.length, 18)
+    assert_equal(r.find { |f| f.tag == "245" }.to_s,
+      "245 10 $a ActivePerl with ASP and ADO / $c Tobias Martinsson. ")
+  end
+
+  def test_encode
+    r1 = MARC::Record.new
+    r1.append(MARC::DataField.new("100", "2", "0", ["a", "Thomas, Dave"]))
+    r1.append(MARC::DataField.new("245", "0", "0", ["a", "Pragmatic Programmer"]))
+    raw = r1.to_marc
+    r2 = MARC::Record.new_from_marc(raw)
+    assert_equal(r1, r2)
+  end
+
+  def test_lookup_shorthand
+    r = get_record
+    assert_equal(r["100"]["a"], "Thomas, Dave")
+  end
+
+  def get_record
+    r = MARC::Record.new
+    r.append(MARC::DataField.new("100", "2", "0", ["a", "Thomas, Dave"]))
+    r.append(MARC::DataField.new("245", "0", "4", ["The Pragmatic Programmer"]))
+    r
+  end
+
+  def test_field_index
+    raw = IO.read("test/random_tag_order.dat")
+    r = MARC::Record.new_from_marc(raw)
+    assert_kind_of(Array, r.fields)
+    assert_kind_of(Array, r.tags)
+    assert_equal(["001", "005", "007", "008", "010", "028", "035", "040", "050", "245", "260", "300", "500", "505", "511", "650", "700", "906", "953", "991"], r.tags.sort)
+    assert_kind_of(Array, r.fields("035"))
+    raw2 = IO.read("test/random_tag_order2.dat")
+    r2 = MARC::Record.new_from_marc(raw2)
+    assert_equal(6, r2.fields("500").length)
+    # Test passing an array to Record#fields
+    assert_equal(3, r.fields(["500", "505", "510", "511"]).length)
+    # Test passing a Range to Record#fields
+    assert_equal(9, r.fields(("001".."099")).length)
+  end
+
+  def test_field_index_order
+    raw = IO.read("test/random_tag_order.dat")
+    r = MARC::Record.new_from_marc(raw)
+    notes = ["500", "505", "511"]
+    r.fields(("500".."599")).each do |f|
+      assert_equal(notes.pop, f.tag)
     end
 
-    def test_frozen_fieldmap
-      r = MARC::Record.new
-      r.fields.push MARC::DataField.new('500', ' ', ' ', ['a', 'notes'])
-
-      r.fields.freeze
-
-      r.fields.inspect
-      r.fields
-      assert ! r.fields('500').empty?
-
-      assert r.fields.instance_variable_get("@clean"), "FieldMap still marked clean"
+    raw2 = IO.read("test/random_tag_order2.dat")
+    r2 = MARC::Record.new_from_marc(raw2)
 
+    fields = ["050", "042", "010", "028", "024", "035", "041", "028", "040", "035", "008", "007", "005", "001"]
+    r2.each_by_tag(("001".."099")) do |f|
+      assert_equal(fields.pop, f.tag)
     end
 
-
+    five_hundreds = r2.fields("500")
+    assert_equal(five_hundreds.first["a"], '"Contemporary blues" interpretations of previously released songs; written by Bob Dylan.')
+    assert_equal(five_hundreds.last["a"], "Composer and program notes in container.")
+  end
+
+  # Some tests for the internal FieldMap hash, normally
+  # an implementation detail, but things get tricky and we need
+  # tests to make sure we're good. Some of these you might
+  # change if you change FieldMap caching implementation or contract/API.
+  def test_direct_change_dirties_fieldmap
+    # if we ask for #fields directly, and mutate it
+    # with it's own methods, does any cache update?
+    r = MARC::Record.new
+    assert r.fields("500").empty?
+    r.fields.push MARC::DataField.new("500", " ", " ", ["a", "notes"])
+    assert !r.fields("500").empty?, "New 505 directly added to #fields is picked up"
+
+    # Do it again, make sure #[] works too
+    r = MARC::Record.new
+    assert r["500"].nil?
+    r.fields.push MARC::DataField.new("500", " ", " ", ["a", "notes"])
+    assert r["500"], "New 505 directly added to #fields is picked up"
+  end
+
+  def test_frozen_fieldmap
+    r = MARC::Record.new
+    r.fields.push MARC::DataField.new("500", " ", " ", ["a", "notes"])
+
+    r.fields.freeze
+
+    r.fields.inspect
+    r.fields
+    assert !r.fields("500").empty?
+
+    assert r.fields.instance_variable_get(:@clean), "FieldMap still marked clean"
+  end
 end

data/test/tc_subfield.rb

@@ -1,18 +1,19 @@
-require 'test/unit'
-require 'marc/subfield'
+require "test/unit"
+require "marc/subfield"
 
 class SubfieldTest < Test::Unit::TestCase
+  def test_ok
+    s = MARC::Subfield.new("a", "foo")
+    assert_equal(s.code, "a")
+    assert_equal(s.value, "foo")
+  end
 
-    def test_ok
-        s = MARC::Subfield.new('a', 'foo')
-        assert_equal(s.code, 'a')
-        assert_equal(s.value, 'foo')
-    end
-
-    def test_equals
-        s1 =MARC::Subfield.new('a', 'foo')
-        s2 =MARC::Subfield.new('a', 'foo')
-        assert_equal(s1,s2)
-    end
+  def test_equals
+    s1 = MARC::Subfield.new("a", "foo")
+    s2 = MARC::Subfield.new("a", "foo")
+    assert_equal(s1, s2)
 
+    assert_not_equal(s1, "a")
+    assert_not_equal(s1, "foo")
+  end
 end

data/test/tc_unsafe_xml.rb

@@ -0,0 +1,95 @@
+require "test/unit"
+require "marc"
+require "stringio"
+
+class UnsafeXMLTest < Test::Unit::TestCase
+  def basic_rec
+    rec = MARC::Record.new
+    rec.leader = "00925njm  22002777a 4500"
+    rec.append MARC::ControlField.new("007", "sdubumennmplu")
+    rec.append MARC::DataField.new("245", "0", "4",
+      ["a", "The Great Ray Charles"], ["h", "[sound recording]."])
+    rec.append MARC::DataField.new("998", " ", " ",
+      ["^", "Valid local subfield"])
+    rec
+  end
+
+  def text_xml_entities
+    r1 = MARC::Record.new
+    r1 << MARC::DataField.new("245", "0", "0", ["a", "foo & bar & baz"])
+    xml = MARC::UnsafeXMLWriter.encode(r1)
+    assert_match(/foo &amp; bar &amp; baz/, xml)
+    reader = MARC::XMLReader.new(StringIO.new(xml), parser: parser)
+    r2 = reader.entries[0]
+    assert_equal "foo & bar & baz", r2["245"]["a"]
+  end
+
+  def test_read_write
+    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.append MARC::DataField.new("998", " ", " ",
+      ["^", "Valid local subfield"])
+
+    writer = MARC::UnsafeXMLWriter.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)
+
+    reader = MARC::XMLReader.new("test/test.xml")
+    record2 = reader.first
+    assert_equal(record1, record2)
+  ensure
+    File.unlink("test/test.xml")
+  end
+
+  def test_truncated_leader_roundtripping
+    record1 = MARC::Record.new
+    record1.leader = "00925njm  22002777a"
+
+    writer = MARC::UnsafeXMLWriter.new("test/test.xml", stylesheet: "style.xsl")
+    writer.write(record1)
+    writer.close
+
+    reader = MARC::XMLReader.new("test/test.xml")
+    record2 = reader.first
+
+    assert_equal("00925njm  22002777a 4500", record2.leader)
+  ensure
+    File.unlink("test/test.xml")
+  end
+
+  def test_single_record_document
+    xml = MARC::UnsafeXMLWriter.single_record_document(basic_rec)
+    rec = MARC::XMLReader.new(StringIO.new(xml)).first
+    assert_equal(basic_rec, rec)
+  end
+
+  def test_encode_same_as_rexml
+    rex_xml = MARC::XMLWriter.encode(basic_rec).to_s
+    unsafe_xml = MARC::UnsafeXMLWriter.encode(basic_rec)
+    rex = MARC::XMLReader.new(StringIO.new(rex_xml)).first
+    unsafe = MARC::XMLReader.new(StringIO.new(unsafe_xml)).first
+    assert_equal(rex, unsafe)
+  end
+
+  def test_to_xml_string
+    rex_xml = basic_rec.to_xml_string
+    unsafe_xml = basic_rec.to_xml_string(fast_but_unsafe: true, include_namespace: false)
+    rex = MARC::XMLReader.new(StringIO.new(rex_xml)).first
+    unsafe = MARC::XMLReader.new(StringIO.new(unsafe_xml)).first
+    assert_equal(rex, unsafe)
+  end
+
+  def test_to_xml_string_with_namespaces
+    unsafe_xml = basic_rec.to_xml_string(fast_but_unsafe: true, include_namespace: true)
+    rex = MARC::XMLReader.new(StringIO.new(unsafe_xml)).first
+    unsafe = MARC::XMLReader.new(StringIO.new(unsafe_xml)).first
+    assert_equal(rex, unsafe)
+  end
+end