marc 0.2.2 → 0.3.0

data/Changes

@@ -1,3 +1,6 @@
+v0.3.0 Wed Sep 23 21:51:00 EDT 2009
+- Nokogiri and jrexml parser integration added as well as Ruby 1.9 support
+
 v0.2.2 Tue Dec 30 09:50:33 EST 2008
 - DataField tags that are all numeric are now padded with leading zeros
 

data/Rakefile

@@ -1,4 +1,4 @@
-RUBY_MARC_VERSION = '0.2.2'
+RUBY_MARC_VERSION = '0.3.0'
 
 require 'rubygems'
 require 'rake'
@@ -21,7 +21,7 @@ spec = Gem::Specification.new do |s|
   s.version = RUBY_MARC_VERSION
   s.author = 'Ed Summers'
   s.email = 'ehs@pobox.com'
-  s.homepage = 'http://www.textualize.com/ruby_marc'
+  s.homepage = 'http://marc.rubyforge.org/'
   s.platform = Gem::Platform::RUBY
   s.summary = 'A ruby library for working with Machine Readable Cataloging'
   s.files = Dir.glob("{lib,test}/**/*") + ["Rakefile", "README", "Changes",
@@ -30,7 +30,7 @@ spec = Gem::Specification.new do |s|
   s.autorequire = 'marc'
   s.has_rdoc = true
   s.required_ruby_version = '>= 1.8.6'
-  
+  s.authors = ["Kevin Clarke", "William Groppe", "Ross Singer", "Ed Summers"]
   s.test_file = 'test/ts_marc.rb'
   s.bindir = 'bin'
 end
@@ -41,7 +41,7 @@ Rake::GemPackageTask.new(spec) do |pkg|
 end
 
 Rake::RDocTask.new('doc') do |rd|
-  rd.rdoc_files.include("lib/**/*.rb")
+  rd.rdoc_files.include("README", "Changes", "LICENSE", "lib/**/*.rb")
   rd.main = 'MARC::Record'
   rd.rdoc_dir = 'doc'
 end

data/lib/marc.rb

@@ -24,6 +24,13 @@
 #    writer = MARC::XMLWriter.new('marc.xml')
 #    writer.write(record)
 #    writer.close()
+#
+#    # Deal with non-standard control field tags
+#    MARC::Field.control_tags << 'FMT'
+#    record = MARC::Record.new()
+#    record.add_field(MARC::ControlField.new('FMT', 'Book')) # doesn't throw an error
+
+
 
 require 'marc/constants'
 require 'marc/record'
@@ -36,3 +43,4 @@ require 'marc/exception'
 require 'marc/xmlwriter'
 require 'marc/xmlreader'
 require 'marc/dublincore'
+require 'marc/xml_parsers'

data/lib/marc/constants.rb

@@ -11,4 +11,8 @@ module MARC
   MARC_NS = "http://www.loc.gov/MARC21/slim"
   MARC_XSD = "http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
 
+  # marc-hash
+  MARCHASH_MAJOR_VERSION = 1
+  MARCHASH_MINOR_VERSION = 0
+  
 end

data/lib/marc/controlfield.rb

@@ -1,10 +1,29 @@
+require 'set'
+
 module MARC
 
   # MARC records contain control fields, each of which has a 
   # tag and value. Tags for control fields must be in the
-  # 001-009 range.
+  # 001-009 range or be specially added to the @@control_tags Set
 
   class ControlField
+    
+    # Initially, control tags are the numbers 1 through 9 or the string '000'
+    @@control_tags = Set.new( (1..9).to_a)
+    @@control_tags << '000'
+ 
+    def self.control_tags
+      return @@control_tags
+    end
+ 
+    # A tag is a control tag if it is a member of the @@control_tags set
+    # as either a string (e.g., 'FMT') or in its .to_i representation
+    # (e.g., '008'.to_i == 3 is in @@control_tags by default)
+  
+    def self.control_tag?(tag)
+      return (@@control_tags.include?(tag.to_i) or @@control_tags.include?(tag))
+    end
+    
 
     # the tag value (007, 008, etc)
     attr_accessor :tag
@@ -18,8 +37,8 @@ module MARC
     def initialize(tag,value='')
       @tag = tag
       @value = value
-      if tag.to_i > 9 
-        raise MARC::Exception.new(), "tag must be greater than 009"
+      if not MARC::ControlField.control_tag?(@tag)
+        raise MARC::Exception.new(), "tag must be in 001-009 or in the MARC::ControlField.control_tags set"
       end
     end
 
@@ -34,13 +53,19 @@ module MARC
       return true
     end
 
+    # turning it into a marc-hash element
+    def to_marchash
+      return [@tag, @value]
+    end
+    
+
     def to_s
       return "#{tag} #{value}" 
     end
 
     def =~(regex)
       return self.to_s =~ regex
-    end
+    end      
 
   end
 

data/lib/marc/datafield.rb

@@ -1,11 +1,14 @@
 require 'marc/subfield'
 require 'marc/record'
+require 'marc/controlfield'
 
 module MARC
 
   # MARC records contain data fields, each of which has a tag, 
-  # indicators and subfields. Tags for data fields must be in
-  # the range 010-999.
+  # indicators and subfields. Tags for data fields must are all
+  # three-character tags that are not control fields (generally,
+  # any numeric tag greater than 009).
+  #
   # Accessor attributes: tag, indicator1, indicator2
   # 
   # DataField mixes in Enumerable to enable access to it's constituent
@@ -63,10 +66,12 @@ module MARC
       @indicator2 = i2 == nil ? ' ' : i2
       @subfields = []
 
-      # must use MARC::ControlField for tags < 010
-      if @tag.to_i < 10 and not @tag =~ /[A-z]/
+      # must use MARC::ControlField for tags < 010 or
+      # those in MARC::ControlField#extra_control_fields
+      
+      if MARC::ControlField.control_tag?(@tag)
         raise MARC::Exception.new(),
-          "MARC::DataField objects can't have tags < 010"
+          "MARC::DataField objects can't have ControlField tag '" + @tag + "')"
       end
 
       # allows MARC::Subfield objects to be passed directly
@@ -78,7 +83,7 @@ module MARC
         when Array
           if subfield.length > 2
             raise MARC::Exception.new(),
-              "arrays must only have 2 elements" 
+              "arrays must only have 2 elements: " + subfield.to_s 
           end
           @subfields.push(
             MARC::Subfield.new(subfield[0],subfield[1]))
@@ -100,6 +105,11 @@ module MARC
       return str
     end
 
+    # Turn into a marc-hash structure
+    def to_marchash
+      return [@tag, @indicator1, @indicator2, @subfields.map {|sf| [sf.code, sf.value]} ]
+    end
+    
 
     # Add a subfield (MARC::Subfield) to the field
     #    field.append(MARC::Subfield.new('a','Dave Thomas'))

data/lib/marc/reader.rb

@@ -16,9 +16,15 @@ module MARC
     #
     #   # marc is a string with a bunch of records in it
     #   reader = MARC::Reader.new(StringIO.new(reader))
+    #
+    # If your data have non-standard control fields in them
+    # (e.g., Aleph's 'FMT') you need to add them specifically
+    # to the MARC::ControlField.control_tags Set object
+    # 
+    #   MARC::ControlField.control_tags << 'FMT'
     
     def initialize(file)
-      if file.class == String:
+      if file.is_a?(String)
         @handle = File.new(file)
       elsif file.respond_to?("read", 5)
         @handle = file
@@ -40,7 +46,7 @@ module MARC
       while rec_length_s = @handle.read(5)
         # make sure the record length looks like an integer
         rec_length_i = rec_length_s.to_i
-        if rec_length_i == 0:
+        if rec_length_i == 0
           raise MARC::Exception.new("invalid record length: #{rec_length_s}")
         end
 
@@ -113,7 +119,7 @@ module MARC
         field_data.delete!(END_OF_FIELD)
          
         # add a control field or data field
-        if tag < '010'
+        if MARC::ControlField.control_tag?(tag)
           record.append(MARC::ControlField.new(tag,field_data))
         else
           field = MARC::DataField.new(tag)

data/lib/marc/record.rb

@@ -1,3 +1,6 @@
+require 'marc/controlfield'
+require 'marc/datafield'
+
 module MARC
 
   # A class that represents an individual MARC record. Every record
@@ -118,11 +121,40 @@ module MARC
       return MARC::DublinCore.map(self)
     end
 
+    # Return a marc-hash version of the record
+    def to_marchash
+      return {
+        'type' => 'marc-hash',
+        'version' => [MARCHASH_MAJOR_VERSION, MARCHASH_MINOR_VERSION],
+        'leader' => self.leader,
+        'fields' => self.map {|f| f.to_marchash}
+      }
+    end #to_hash
+    
+    # Factory method for creating a new MARC::Record from
+    # a marchash object
+    #
+    # record = MARC::Record->new_from_marchash(mh)
+    
+    def self.new_from_marchash(mh)
+      r = self.new()
+      r.leader = mh['leader']
+      mh['fields'].each do |f|
+        if (f.length == 2) 
+          r << MARC::ControlField.new(f[0], f[1])
+        elsif 
+          r << MARC::DataField.new(f[0], f[1], f[2], *f[3])
+        end
+      end
+      return r
+    end
+    
+
     # Returns a string version of the record, suitable for printing
 
     def to_s
       str = "LEADER #{leader}\n"
-      for field in fields:
+      for field in fields
         str += field.to_s() + "\n"
       end
       return str

data/lib/marc/xml_parsers.rb

@@ -0,0 +1,288 @@
+module MARC
+  # The MagicReader will try to use the best available XML Parser at the
+  # time of initialization.  
+  # The order is currently:
+  #   * Nokogiri
+  #   * jrexml (JRuby only)
+  #   * rexml
+  #
+  # With the idea that other parsers could be added as their modules are
+  # added.  Realistically, this list should be limited to stream-based
+  # parsers.  The magic should be used selectively, however.  After all,
+  # one project's definition of 'best' might not apply universally.  It
+  # is arguable which is "best" on JRuby:  Nokogiri or jrexml.  
+  module MagicReader    
+    def self.extended(receiver)
+      # Start with a Nokogiri check
+      begin
+        require 'nokogiri'
+        receiver.extend(NokogiriReader)
+      rescue LoadError
+        if RUBY_PLATFORM =~ /java/
+          # If using JRuby, use JREXML if it's there
+          begin
+            receiver.extend(JREXMLReader)
+            return
+          rescue LoadError
+          end
+        end       
+        # If you're here, you're stuck with lowly REXML
+        receiver.extend(REXMLReader) 
+      end        
+    end
+  end
+  
+  # NokogiriReader uses the Nokogiri SAX Parser to quickly read
+  # a MARCXML document.  Because dynamically subclassing MARC::XMLReader
+  # is a little ugly, we need to recreate all of the SAX event methods
+  # from Nokogiri::XML::SAX::Document here rather than subclassing.    
+  module NokogiriReader    
+    def self.extended(receiver)
+      require 'nokogiri'
+      receiver.init
+    end
+    
+    # Sets our instance variables for SAX parsing in Nokogiri and parser
+    def init
+      @record = {:record=>nil,:field=>nil,:subfield=>nil}
+      @current_element = nil
+      @ns = "http://www.loc.gov/MARC21/slim"
+      @parser = Nokogiri::XML::SAX::Parser.new(self)         
+    end
+    
+    # Loop through the MARC records in the XML document
+    def each(&block)    
+      @block = block
+      @parser.parse(@handle)
+    end
+        
+    # Returns our MARC::Record object to the #each block.
+    def yield_record
+      @block.call(@record[:record])       
+      @record[:record] = nil
+    end    
+    
+    def start_element_namespace name, attributes = [], prefix = nil, uri = nil, ns = {}
+      attributes = attributes_to_hash(attributes)
+      if uri == @ns
+        case name.downcase
+        when 'record' then @record[:record] = MARC::Record.new
+        when 'leader' then @current_element = :leader
+        when 'controlfield'
+          @current_element=:field
+          @record[:field] = MARC::ControlField.new(attributes["tag"])
+        when 'datafield'
+          @record[:field] = MARC::DataField.new(attributes["tag"], attributes['ind1'], attributes['ind2'])
+        when 'subfield'
+          @current_element=:subfield
+          @record[:subfield] = MARC::Subfield.new(attributes['code'])
+        end
+      end
+    end
+
+    def characters text
+      case @current_element
+      when :leader then @record[:record].leader = text
+      when :field then @record[:field].value << text
+      when :subfield then @record[:subfield].value << text
+      end
+    end
+
+    def end_element_namespace name, prefix = nil, uri = nil
+      @current_element = nil
+      if uri == "http://www.loc.gov/MARC21/slim"
+        case name.downcase
+        when 'record' then yield_record
+        when /(control|data)field/
+          @record[:record] << @record[:field]
+          @record[:field] = nil
+          @current_element = nil if @current_element == :field          
+        when 'subfield'
+          @record[:field].append(@record[:subfield])
+          @record[:subfield] = nil
+          @current_element = nil if @current_element == :subfield
+        end
+      end
+    end
+    
+    def method_missing(methName, *args)
+      sax_methods = [:xmldecl, :start_document, :end_document, :start_element,
+        :end_element, :comment, :warning, :error, :cdata_block]
+      unless sax_methods.index(methName)
+        raise NoMethodError.new("undefined method '#{methName} for #{self}", 'no_meth')
+      end
+    end
+     
+     private 
+
+     def attributes_to_hash(attributes)
+       hash = {}
+       attributes.each do | att |
+         hash[att.localname] = att.value
+       end
+       hash
+     end     
+  end
+  
+  # The REXMLReader is the 'default' parser, since we can at least be
+  # assured that REXML is probably there.  It uses REXML's PullParser
+  # to handle larger document sizes without consuming insane amounts of
+  # memory, but it's still REXML (read: slow), so it's a good idea to 
+  # use an alternative parser if available.  If you don't know the best
+  # parser available, you can use the MagicReader or set:
+  #
+  # MARC::XMLReader.parser=MARC::XMLReader::USE_BEST_AVAILABLE
+  #
+  # or
+  #
+  # MARC::XMLReader.parser="magic"
+  #
+  # or
+  #
+  # reader = MARC::XMLReader.new(fh, :parser=>"magic") 
+  # (or the constant)
+  #
+  # which will cascade down to REXML if nothing better is found.
+  #  
+  module REXMLReader
+    def self.extended(receiver)
+      require 'rexml/document'
+      require 'rexml/parsers/pullparser'
+      receiver.init
+    end
+    
+    # Sets our parser
+    def init
+      @parser = REXML::Parsers::PullParser.new(@handle)
+    end
+    
+    # Loop through the MARC records in the XML document
+    def each
+      while @parser.has_next?
+        event = @parser.pull
+        # if it's the start of a record element 
+        if event.start_element? and strip_ns(event[0]) == 'record'
+          yield build_record
+        end
+      end    
+    end
+    
+    private
+    def strip_ns(str)
+      return str.sub(/^.*:/, '')
+    end
+    
+    # will accept parse events until a record has been built up
+    #
+    def build_record
+      record = MARC::Record.new
+      data_field = nil
+      control_field = nil
+      subfield = nil
+      text = '' 
+      attrs = nil
+      if Module.constants.index('Nokogiri') and @parser.is_a?(Nokogiri::XML::Reader)
+        datafield = nil
+        cursor = nil
+        open_elements = []
+        @parser.each do | node |
+          if node.value? && cursor
+            if cursor.is_a?(Symbol) and cursor == :leader
+              record.leader = node.value
+            else
+              cursor.value = node.value
+            end
+            cursor = nil
+          end
+          next unless node.namespace_uri == @ns
+          if open_elements.index(node.local_name.downcase)
+            open_elements.delete(node.local_name.downcase)
+            next
+          else
+            open_elements << node.local_name.downcase
+          end
+          case node.local_name.downcase
+          when "leader"
+            cursor = :leader
+          when "controlfield"
+            record << datafield if datafield
+            datafield = nil
+            control_field = MARC::ControlField.new(node.attribute('tag'))
+            record << control_field
+            cursor = control_field
+          when "datafield"  
+            record << datafield if datafield
+            datafield = nil
+            data_field = MARC::DataField.new(node.attribute('tag'), node.attribute('ind1'), node.attribute('ind2'))
+            datafield = data_field
+          when "subfield"
+            raise "No datafield to add to" unless datafield
+            subfield = MARC::Subfield.new(node.attribute('code'))
+            datafield.append(subfield)
+            cursor = subfield
+          when "record"
+            record << datafield if datafield
+            return record
+          end          
+          #puts node.name
+        end
+        
+      else
+        while @parser.has_next?
+          event = @parser.pull
+
+          if event.text?
+            text += REXML::Text::unnormalize(event[0])
+            next
+          end
+
+          if event.start_element?
+            text = ''
+            attrs = event[1]
+            case strip_ns(event[0])
+            when 'controlfield'
+              text = ''
+              control_field = MARC::ControlField.new(attrs['tag'])
+            when 'datafield'
+              text = ''
+              data_field = MARC::DataField.new(attrs['tag'], attrs['ind1'], 
+                attrs['ind2'])
+            when 'subfield'
+              text = ''
+              subfield = MARC::Subfield.new(attrs['code'])
+            end
+          end
+
+          if event.end_element?
+            case strip_ns(event[0])
+            when 'leader'
+              record.leader = text
+            when 'record'
+              return record
+            when 'controlfield'
+              control_field.value = text
+              record.append(control_field)
+            when 'datafield'
+              record.append(data_field)
+            when 'subfield'
+              subfield.value = text
+              data_field.append(subfield)
+            end
+          end
+        end
+      end
+    end        
+  end
+  
+  # The JREXMLReader is really just here to set the load order for
+  # injecting the Java pull parser.  
+  module JREXMLReader
+
+    def self.extended(receiver)
+      require 'rexml/document'
+      require 'rexml/parsers/pullparser'
+      require 'jrexml'
+      receiver.extend(REXMLReader)
+    end
+  end
+end

data/lib/marc/xmlreader.rb

@@ -1,103 +1,142 @@
-require 'rexml/document'
-require 'rexml/parsers/pullparser'
-
+require File.dirname(__FILE__) + '/xml_parsers'
 module MARC
-  
+
+  # the constructor which you can pass either a filename:
+  #
+  #   reader = MARC::XMLReader.new('/Users/edsu/marc.xml')
+  #
+  # or a File object, 
+  #
+  #   reader = Marc::XMLReader.new(File.new('/Users/edsu/marc.xml'))
+  #
+  # or really any object that responds to read(n)
+  # 
+  #   reader = MARC::XMLReader.new(StringIO.new(xml))
+  #
+  # By default, XMLReader uses REXML's pull parser, but you can swap
+  # that out with Nokogiri or jrexml (or let the system choose the
+  # 'best' one).  The :parser can either be one of the defined constants
+  # or the constant's value.
+  #
+  #   reader = MARC::XMLReader.new(fh, :parser=>'magic') 
+  #
+  # It is also possible to set the default parser at the class level so
+  # all subsequent instances will use it instead:
+  #
+  #   MARC::XMLReader.best_available
+  #   "nokogiri" # returns parser name, but doesn't set it.
+  #
+  # Use:
+  #   MARC::XMLReader.best_available!
+  # 
+  # or
+  #   MARC::XMLReader.nokogiri!
+  # 
   class XMLReader
     include Enumerable
-
-    # the constructor which you can pass either a filename:
-    #
-    #   reader = MARC::XMLReader.new('/Users/edsu/marc.xml')
-    #
-    # or a File object, 
-    #
-    #   reader = Marc::XMLReader.new(File.new('/Users/edsu/marc.xml'))
-    #
-    # or really any object that responds to read(n)
-    # 
-    #   reader = MARC::XMLReader.new(StringIO.new(xml))
+    USE_BEST_AVAILABLE = 'magic'
+    USE_REXML = 'rexml'
+    USE_NOKOGIRI = 'nokogiri'
+    USE_JREXML = 'jrexml'
+    @@parser = USE_REXML
+    attr_reader :parser
  
-    def initialize(file)
-      if file.class == String:
+    def initialize(file, options = {})
+      if file.is_a?(String)
         handle = File.new(file)
       elsif file.respond_to?("read", 5)
         handle = file
       else
         throw "must pass in path or File"
       end
+      @handle = handle
 
-      @parser = REXML::Parsers::PullParser.new(handle)
-    end
-
-    def each
-      while @parser.has_next?
-        event = @parser.pull
-        # if it's the start of a record element 
-        if event.start_element? and strip_ns(event[0]) == 'record'
-          yield build_record
-        end
+      if options[:parser]
+        parser = self.class.choose_parser(options[:parser].to_s)
+      else
+        parser = @@parser
+      end
+      case parser
+      when 'magic' then extend MagicReader
+      when 'rexml' then extend REXMLReader
+      when 'jrexml' then extend JREXMLReader
+      when 'nokogiri' then extend NokogiriReader        
       end
     end
 
-    private
-
-    def strip_ns(str)
-      return str.sub(/^.*:/, '')
+    # Returns the currently set parser type
+    def self.parser
+      return @@parser
+    end
+    
+    # Returns an array of all the parsers available
+    def self.parsers
+      p = []
+      self.constants.each do | const |
+        next unless const.match("^USE_")
+        p << const
+      end      
+      return p
+    end
+    
+    # Sets the class parser
+    def self.parser=(p)
+      @@parser = choose_parser(p)
     end
 
-    # will accept parse events until a record has been built up
-    #
-    def build_record
-      record = MARC::Record.new
-      data_field = nil
-      control_field = nil
-      subfield = nil
-      text = '' 
-      attrs = nil
-
-      while @parser.has_next?
-        event = @parser.pull
-
-        if event.text?
-          text += REXML::Text::unnormalize(event[0])
-          next
-        end
-
-        if event.start_element?
-          text = ''
-          attrs = event[1]
-          case strip_ns(event[0])
-          when 'controlfield'
-            text = ''
-            control_field = MARC::ControlField.new(attrs['tag'])
-          when 'datafield'
-            text = ''
-            data_field = MARC::DataField.new(attrs['tag'], attrs['ind1'], 
-              attrs['ind2'])
-          when 'subfield'
-            text = ''
-            subfield = MARC::Subfield.new(attrs['code'])
+    # Returns the value of the best available parser
+    def self.best_available
+      parser = nil
+      begin
+        require 'nokogiri'
+        parser = USE_NOKOGIRI
+      rescue LoadError
+        if RUBY_PLATFORM =~ /java/
+          begin
+            require 'jrexml'
+            parser = USE_JREXML
+          rescue LoadError
+            parser = USE_REXML
           end
+        else
+          parser = USE_REXML
         end
-
-        if event.end_element?
-          case strip_ns(event[0])
-          when 'leader'
-            record.leader = text
-          when 'record'
-            return record
-          when 'controlfield'
-            control_field.value = text
-            record.append(control_field)
-          when 'datafield'
-            record.append(data_field)
-          when 'subfield'
-            subfield.value = text
-            data_field.append(subfield)
-          end
+        parser
+      end            
+    end
+    
+    # Sets the best available parser as the default
+    def self.best_available!
+      @@parser = self.best_available
+    end
+    
+    # Sets Nokogiri as the default parser
+    def self.nokogiri!
+      @@parser = USE_NOKOGIRI
+    end
+    
+    # Sets jrexml as the default parser
+    def self.jrexml!
+      @@parser = USE_JREXML
+    end
+    
+    # Sets REXML as the default parser
+    def self.rexml!
+      @@parser = USE_REXML
+    end
+        
+    protected
+    
+    def self.choose_parser(p)
+      match = false
+      self.constants.each do | const |
+        next unless const.to_s.match("^USE_")
+        if self.const_get(const) == p
+          match = true
+          return p
         end
       end
+      raise ArgumentError.new("Parser '#{p}' not defined") unless match
     end
   end
 end

data/lib/marc/xmlwriter.rb

@@ -137,7 +137,7 @@ module MARC
           control_element = REXML::Element.new("controlfield")
           
           # We need a marker for invalid tag values (we use 000)
-          unless field.tag.match(ctrlFieldTag)
+          unless field.tag.match(ctrlFieldTag) or MARC::Field.control_tag?(ctrlFieldTag)
             field.tag = "00z"
           end
           

data/test/tc_controlfield.rb

@@ -15,6 +15,31 @@ class TestField < Test::Unit::TestCase
     end
   end
 
+  def test_alpha_control_field
+    assert_raise(MARC::Exception) do
+      # can't have a field with a tag < 010
+      field = MARC::ControlField.new('DDD') 
+    end
+  end
+  
+  def test_extra_control_field
+    MARC::ControlField.control_tags << 'FMT'
+    assert_nothing_raised do
+       field = MARC::ControlField.new('FMT') 
+    end
+    assert_raise(MARC::Exception) do
+      field = MARC::DataField.new('FMT') 
+    end
+    MARC::ControlField.control_tags.delete('FMT')
+    assert_nothing_raised do
+       field = MARC::DataField.new('FMT') 
+    end
+    assert_raise(MARC::Exception) do
+      field = MARC::ControlField.new('FMT') 
+    end
+    
+  end
+
   def test_control_as_field
     assert_raise(MARC::Exception) do
       # can't have a control with a tag > 009

data/test/tc_marchash.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'marc'
+require 'rubygems'
+
+class TestMARCHASH < Test::Unit::TestCase
+
+  def test_simple
+    simple = {
+      'type' => 'marc-hash',
+      'version' => [1,0],
+      'leader' => 'LEADER',
+      'fields' => [
+        ['245', '1', '0', 
+          [
+            ['a', 'TITLE'],
+            ['b', 'SUBTITLE']
+          ]
+        ]
+      ]
+    }
+    r = MARC::Record.new()
+    r.leader = 'LEADER'
+    f = MARC::DataField.new('245', '1', '0', ['a', 'TITLE'], ['b', 'SUBTITLE'])
+    r << f
+    assert_equal(r.to_marchash, simple)
+  end
+
+  def test_real
+    reader = MARC::Reader.new('test/batch.dat')
+    reader.each do |r|
+      x = MARC::Record.new_from_marchash(r.to_marchash)
+      assert_equal(r,x)
+    end
+  end
+  
+  
+end

data/test/tc_parsers.rb

@@ -0,0 +1,154 @@
+require 'test/unit'
+require 'marc'
+
+class ParsersTest < Test::Unit::TestCase
+  def test_parser_default
+    assert_equal("rexml", MARC::XMLReader.parser)
+    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
+  end
+  
+  def test_set_jrexml
+    if RUBY_PLATFORM =~ /java/
+      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_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')
+    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')
+    assert_kind_of(REXML::Parsers::PullParser, reader.parser)
+    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)    
+  end
+  
+  def test_set_magic
+    magic_parser = nil
+    begin
+      require 'nokogiri'
+      magic_parser = Nokogiri::XML::SAX::Parser
+    rescue LoadError
+      magic_parser = REXML::Parsers::PullParser
+    end
+    puts "\nTesting 'test_set_magic' for parser: #{magic_parser}"
+    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')
+    assert_kind_of(magic_parser, reader.parser)
+    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')
+    assert_kind_of(magic_parser, reader.parser)
+    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  
+  
+  def test_parser_set_convenience_methods
+    parser_name = nil
+    parser = nil
+    begin
+      require 'nokogiri'
+      parser_name = 'nokogiri'
+      parser = Nokogiri::XML::SAX::Parser
+    rescue LoadError
+      parser = REXML::Parsers::PullParser
+      parser = 'rexml'
+      if RUBY_PLATFORM =~ /java/
+        begin
+          require 'jrexml'
+          parser_name = 'jrexml'
+        rescue LoadError
+        end
+      end
+    end
+    assert_equal(parser_name, MARC::XMLReader.best_available)
+    MARC::XMLReader.best_available!
+    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'
+      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 RUBY_PLATFORM =~ /java/
+      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"
+    end
+  end
+    
+  def teardown
+    MARC::XMLReader.parser=MARC::XMLReader::USE_REXML
+  end
+  
+end

data/test/tc_record.rb

@@ -12,7 +12,12 @@ class TestRecord < Test::Unit::TestCase
       r = get_record()
       doc = r.to_xml
       assert_kind_of REXML::Element, doc
-      assert_equal "<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
+      if RUBY_VERSION < '1.9.0'
+        assert_equal "<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
+      else
+        # REXML inexplicably sorts the attributes alphabetically in Ruby 1.9
+        assert_equal "<record xmlns='http://www.loc.gov/MARC21/slim'><leader>      Z   22        4500</leader><datafield ind1='2' ind2='0' tag='100'><subfield code='a'>Thomas, Dave</subfield></datafield><datafield ind1='0' ind2='4' tag='245'><subfield code='The Pragmatic Programmer'></subfield></datafield></record>", doc.to_s        
+      end
     end
 
     def test_append_field

data/test/tc_xml.rb

@@ -3,20 +3,50 @@ require 'marc'
 require 'stringio'
 
 class XMLTest < Test::Unit::TestCase
+  def setup
+    @parsers = [:rexml]
+    begin
+      require 'nokogiri'
+      @parsers << :nokogiri
+    rescue LoadError
+    end
+    if RUBY_PLATFORM =~ /java/
+      begin
+        require 'jrexml'
+        @parsers << :jrexml
+      rescue LoadError
+      end
+    end
+  end
 
-  def test_xml_entities
+
+  def test_xml_entities    
+    @parsers.each do | parser |
+      puts "\nRunning test_xml_entities with: #{parser}.\n"
+      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'])
     xml = r1.to_xml.to_s
     assert_match /foo &amp; bar &amp; baz/, xml
 
-    reader = MARC::XMLReader.new(StringIO.new(xml))
+    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']    
   end
-
+  
   def test_batch
-    reader = MARC::XMLReader.new('test/batch.xml')
+    @parsers.each do | parser |
+      puts "\nRunning test_batch with: #{parser}.\n"
+      batch_test(parser)
+    end    
+  end
+  
+  def batch_test(parser)
+    reader = MARC::XMLReader.new('test/batch.xml', :parser=>parser)
     count = 0
     for record in reader
       count += 1
@@ -24,15 +54,29 @@ class XMLTest < Test::Unit::TestCase
     end
     assert_equal(count, 2)
   end
-
+  
   def test_read_string
+    @parsers.each do | parser |
+      puts "\nRunning test_read_string with: #{parser}.\n"
+      read_string_test(parser)
+    end  
+  end
+
+  def read_string_test(parser)
     xml = File.new('test/batch.xml').read
-    reader = MARC::XMLReader.new(StringIO.new(xml))
+    reader = MARC::XMLReader.new(StringIO.new(xml), :parser=>parser)
     assert_equal 2, reader.entries.length
   end
   
   def test_non_numeric_fields
-    reader = MARC::XMLReader.new('test/non-numeric.xml')
+    @parsers.each do | parser |
+      puts "\nRunning test_non_numeric_fields with: #{parser}.\n"
+      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 |
@@ -45,21 +89,42 @@ class XMLTest < Test::Unit::TestCase
     end
 
   def test_read_no_leading_zero_write_leading_zero
-    reader = MARC::XMLReader.new('test/no-leading-zero.xml')
+    @parsers.each do | parser |
+      puts "\nRunning test_read_no_leading_zero_write_leading_zero with: #{parser}.\n"
+      read_no_leading_zero_write_leading_zero_test(parser)
+    end    
+  end
+  
+  def read_no_leading_zero_write_leading_zero_test(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)
   end
 
   def test_leader_from_xml
-    reader = MARC::XMLReader.new('test/one.xml')
+    @parsers.each do | parser |
+      puts "\nRunning test_leader_from_xml with: #{parser}.\n"
+      leader_from_xml_test(parser)
+    end
+  end    
+
+  def leader_from_xml_test(parser)
+    reader = MARC::XMLReader.new('test/one.xml', :parser=>parser)
     record = reader.entries[0]
     assert_equal '     njm a22     uu 4500', record.leader
     # 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
   end
-
+  
   def test_read_write
+    @parsers.each do | parser |
+      puts "\nRunning test_read_write with: #{parser}.\n"
+      read_write_test(parser)
+    end
+  end    
+
+  def read_write_test(parser)
     record1 = MARC::Record.new
     record1.leader =  '00925njm  22002777a 4500'
     record1.append MARC::ControlField.new('007', 'sdubumennmplu')
@@ -74,7 +139,7 @@ class XMLTest < Test::Unit::TestCase
     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')
+    reader = MARC::XMLReader.new('test/test.xml', :parser=>parser)
     record2 = reader.entries[0]
     assert_equal(record1, record2)
 

metadata

@@ -1,15 +1,18 @@
 --- !ruby/object:Gem::Specification 
 name: marc
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors: 
+- Kevin Clarke
+- William Groppe
+- Ross Singer
 - Ed Summers
 autorequire: marc
 bindir: bin
 cert_chain: []
 
-date: 2008-12-30 00:00:00 -05:00
+date: 2009-09-23 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -22,41 +25,45 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/marc.rb
-- lib/marc
-- lib/marc/xmlwriter.rb
+- lib/marc/constants.rb
 - lib/marc/controlfield.rb
-- lib/marc/xmlreader.rb
+- lib/marc/datafield.rb
+- lib/marc/dublincore.rb
+- lib/marc/exception.rb
 - lib/marc/reader.rb
 - lib/marc/record.rb
-- lib/marc/exception.rb
-- lib/marc/datafield.rb
 - lib/marc/subfield.rb
-- lib/marc/constants.rb
-- lib/marc/dublincore.rb
 - lib/marc/writer.rb
+- lib/marc/xml_parsers.rb
+- lib/marc/xmlreader.rb
+- lib/marc/xmlwriter.rb
+- lib/marc.rb
+- test/batch.dat
+- test/batch.xml
+- test/no-leading-zero.xml
 - test/non-numeric.dat
-- test/tc_dublincore.rb
-- test/tc_datafield.rb
 - test/non-numeric.xml
-- test/no-leading-zero.xml
-- test/ts_marc.rb
-- test/tc_writer.rb
-- test/batch.xml
-- test/tc_xml.rb
 - test/one.dat
-- test/tc_record.rb
 - test/one.xml
-- test/batch.dat
 - test/tc_controlfield.rb
+- test/tc_datafield.rb
+- test/tc_dublincore.rb
+- test/tc_marchash.rb
+- test/tc_parsers.rb
 - test/tc_reader.rb
+- test/tc_record.rb
 - test/tc_subfield.rb
+- test/tc_writer.rb
+- test/tc_xml.rb
+- test/ts_marc.rb
 - Rakefile
 - README
 - Changes
 - LICENSE
 has_rdoc: true
-homepage: http://www.textualize.com/ruby_marc
+homepage: http://marc.rubyforge.org/
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -77,9 +84,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A ruby library for working with Machine Readable Cataloging
 test_files: 
 - test/ts_marc.rb