marc 0.3.0 → 0.3.1

data/Rakefile

@@ -1,4 +1,4 @@
-RUBY_MARC_VERSION = '0.3.0'
+RUBY_MARC_VERSION = '0.3.1'
 
 require 'rubygems'
 require 'rake'

data/lib/marc/xml_parsers.rb

@@ -13,72 +13,49 @@ module MARC
   # 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        
+      magic = MARC::XMLReader.best_available
+      case magic
+      when 'nokogiri' then receiver.extend(NokogiriReader)
+      when 'libxml' then receiver.extend(LibXMLReader)
+      when 'jstax' then receiver.extend(JRubySTAXReader)
+      when 'jrexml' then receiver.extend(JREXMLReader)
+      else 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
+  module GenericPullParser
+    # Submodules must include
+    #  self.extended()
+    #  init()
+    #  attributes_to_hash(attributes)
+    #  each
     
-    # 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
+       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
@@ -90,7 +67,7 @@ module MARC
 
     def end_element_namespace name, prefix = nil, uri = nil
       @current_element = nil
-      if uri == "http://www.loc.gov/MARC21/slim"
+      if uri == @ns
         case name.downcase
         when 'record' then yield_record
         when /(control|data)field/
@@ -103,8 +80,36 @@ module MARC
           @current_element = nil if @current_element == :subfield
         end
       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 
+    include GenericPullParser
+    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
+        
+
     def method_missing(methName, *args)
       sax_methods = [:xmldecl, :start_document, :end_document, :start_element,
         :end_element, :comment, :warning, :error, :cdata_block]
@@ -123,6 +128,8 @@ module MARC
        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
@@ -285,4 +292,106 @@ module MARC
       receiver.extend(REXMLReader)
     end
   end
+  
+  module LibXMLReader
+
+    def self.extended(receiver)
+      require 'xml'
+      receiver.init
+    end
+
+    def init
+      @ns = "http://www.loc.gov/MARC21/slim"
+      @parser = XML::Reader.io(@handle)
+    end
+
+    def each
+      while (@parser.read) do
+       if @parser.local_name == 'record' && @parser.namespace_uri == @ns
+         yield build_record
+       end
+      end # while
+    end # each
+
+    def build_record
+      r = MARC::Record.new()
+        until (@parser.local_name == 'record' and @parser.node_type == XML::Reader::TYPE_END_ELEMENT) do
+          @parser.read
+          next if @parser.node_type == XML::Reader::TYPE_END_ELEMENT
+          case @parser.local_name
+          when 'leader'
+           @parser.read
+           r.leader = @parser.value
+          when 'controlfield'
+           tag = @parser['tag']
+           @parser.read
+           r << MARC::ControlField.new(tag, @parser.value)
+          when 'datafield'
+           data = MARC::DataField.new(@parser['tag'], @parser['ind1'], @parser['ind2'])
+           while (@parser.read and !(@parser.local_name == 'datafield' and @parser.node_type == XML::Reader::TYPE_END_ELEMENT)) do
+             next if @parser.node_type == XML::Reader::TYPE_END_ELEMENT
+             case @parser.local_name
+             when 'subfield'
+               code =@parser['code']
+               @parser.read
+               data.append(MARC::Subfield.new(code, @parser.value))
+             end
+           end
+           r << data
+
+          end # case
+        end #until
+      return r
+    end
+  end
+
+  # The JrubySTAXReader uses native java calls to parse the incoming stream
+  # of marc-xml. It includes most of the work from GenericPullParser
+
+  if defined? JRUBY_VERSION
+    module JRubySTAXReader
+      include GenericPullParser
+      def self.extended(receiver)
+        include Java
+        java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
+        include javax.xml.stream       
+        receiver.init
+      end
+
+      def init
+        @record = {:record=>nil,:field=>nil,:subfield=>nil}
+        @current_element = nil
+        @ns = "http://www.loc.gov/MARC21/slim"
+        @factory = javax.xml.stream.XMLInputFactory.newInstance
+        @parser = @factory.createXMLStreamReader(@handle.to_inputstream)
+      end
+
+      # Loop through the MARC records in the XML document
+      def each(&block)    
+        @block = block
+        parser_dispatch
+      end
+
+      def parser_dispatch
+        while event = @parser.next and event != XMLStreamConstants.END_DOCUMENT do
+          case event
+            when XMLStreamConstants.START_ELEMENT
+              start_element_namespace(@parser.getLocalName, [], nil,  @parser.getNamespaceURI, nil)
+            when XMLStreamConstants.END_ELEMENT
+              end_element_namespace(@parser.getLocalName, @parser.getPrefix, @parser.getNamespaceURI)
+            when XMLStreamConstants.CHARACTERS
+              characters(@parser.getText)
+          end
+        end
+      end
+
+      def attributes_to_hash(attributes)
+        hash = {}
+        @parser.getAttributeCount.times do | i |
+          hash[@parser.getAttributeName(i).getLocalPart] = @parser.getAttributeValue(i)
+        end
+        hash
+      end     
+    end # end of module
+  end # end of if jruby  
 end

data/lib/marc/xmlreader.rb

@@ -38,6 +38,8 @@ module MARC
     USE_REXML = 'rexml'
     USE_NOKOGIRI = 'nokogiri'
     USE_JREXML = 'jrexml'
+    USE_JSTAX = 'jstax'
+    USE_LIBXML = 'libxml'    
     @@parser = USE_REXML
     attr_reader :parser
  
@@ -59,8 +61,14 @@ module MARC
       case parser
       when 'magic' then extend MagicReader
       when 'rexml' then extend REXMLReader
-      when 'jrexml' then extend JREXMLReader
-      when 'nokogiri' then extend NokogiriReader        
+      when 'jrexml' then 
+        raise ArgumentError, "jrexml only available under jruby" unless defined? JRUBY_VERSION
+        extend JREXMLReader
+      when 'nokogiri' then extend NokogiriReader    
+      when 'jstax' then 
+        raise ArgumentError, "jstax only available under jruby" unless defined? JRUBY_VERSION
+        extend JRubySTAXReader
+      when 'libxml' then extend LibXMLReader
       end
     end
 
@@ -87,22 +95,44 @@ module MARC
     # 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/
+      jruby = [USE_JSTAX, USE_NOKOGIRI, USE_JREXML]
+      ruby = [USE_NOKOGIRI, USE_LIBXML]
+      if defined? JRUBY_VERSION
+        begin
+          java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
+          parser = USE_JSTAX
+        rescue java.lang.ClassNotFoundException
+        end
+        unless parser
           begin
-            require 'jrexml'
-            parser = USE_JREXML
+            require 'nokogiri'
+            parser = USE_NOKOGIRI              
           rescue LoadError
-            parser = USE_REXML
           end
-        else
-          parser = USE_REXML
         end
-        parser
-      end            
+        unless parser
+          begin
+            require 'jrexml'
+            parser = USE_JREXML    
+          rescue LoadError                        
+          end
+        end              
+      else
+        begin
+          require 'nokogiri'
+          parser = USE_NOKOGIRI        
+        rescue LoadError          
+        end
+        unless parser
+          begin
+            require 'xml'
+            parser = USE_LIBXML
+          rescue LoadError
+          end
+        end        
+      end
+      parser = USE_REXML unless parser
+      parser
     end
     
     # Sets the best available parser as the default

data/test/tc_parsers.rb

@@ -34,7 +34,7 @@ class ParsersTest < Test::Unit::TestCase
   end
   
   def test_set_jrexml
-    if RUBY_PLATFORM =~ /java/
+    if defined? JRUBY_VERSION
       begin
         require 'jrexml'
         reader = MARC::XMLReader.new('test/one.xml', :parser=>MARC::XMLReader::USE_JREXML)
@@ -59,6 +59,35 @@ class ParsersTest < Test::Unit::TestCase
     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"
+  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)
@@ -77,13 +106,8 @@ class ParsersTest < Test::Unit::TestCase
   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
+    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)
     assert_kind_of(magic_parser, reader.parser)
@@ -102,23 +126,9 @@ class ParsersTest < Test::Unit::TestCase
   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
+    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')
@@ -133,7 +143,7 @@ class ParsersTest < Test::Unit::TestCase
     else
       puts "\nNokogiri not loaded, skipping convenience method test.\n"
     end
-    if RUBY_PLATFORM =~ /java/
+    if defined? JRUBY_VERSION
       begin
         require 'jrexml'    
         MARC::XMLReader.jrexml!
@@ -151,4 +161,49 @@ class ParsersTest < Test::Unit::TestCase
     MARC::XMLReader.parser=MARC::XMLReader::USE_REXML
   end
   
+  def choose_best_available_parser
+    parser_name = nil
+    parser = nil
+    if defined? JRUBY_VERSION
+      begin
+        java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
+        parser_name = "jstax"
+        parser = Java::ComSunOrgApacheXercesInternalImpl::XMLStreamReaderImpl
+      rescue java.lang.ClassNotFoundException
+      end
+    end
+    unless parser    
+      begin
+        require 'nokogiri'
+        parser_name = 'nokogiri'
+        parser = Nokogiri::XML::SAX::Parser
+      rescue LoadError
+      end
+    end
+    unless parser
+      if !defined? JRUBY_VERSION
+        begin
+          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'
+      end
+    end    
+    return {:parser=>parser, :parser_name=>parser_name}
+  end
+  
 end

data/test/tc_xml.rb

@@ -10,12 +10,22 @@ class XMLTest < Test::Unit::TestCase
       @parsers << :nokogiri
     rescue LoadError
     end
-    if RUBY_PLATFORM =~ /java/
+    begin
+      require 'xml'
+      @parsers << :libxml
+    rescue LoadError
+    end
+    if defined? JRUBY_VERSION
       begin
         require 'jrexml'
         @parsers << :jrexml
       rescue LoadError
       end
+      begin
+        java.lang.Class.forName("javax.xml.stream.XMLInputFactory")
+        @parsers << :jstax
+      rescue java.lang.ClassNotFoundException
+      end
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: marc
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Kevin Clarke
@@ -12,7 +12,7 @@ autorequire: marc
 bindir: bin
 cert_chain: []
 
-date: 2009-09-23 00:00:00 -04:00
+date: 2009-12-14 00:00:00 -05:00
 default_executable: 
 dependencies: []