rbook-onix 0.5.2 → 0.6.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/testtask'
 require "rake/gempackagetask"
 require 'spec/rake/spectask'
 
-PKG_VERSION = "0.5.2"
+PKG_VERSION = "0.6.0"
 PKG_NAME = "rbook-onix"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 RUBYFORGE_PROJECT = 'rbook'
@@ -80,6 +80,8 @@ spec = Gem::Specification.new do |spec|
 	spec.rdoc_options << '--title' << 'onix Documentation' <<
 	                     '--main'  << 'README' << '-q'
   spec.add_dependency('rbook-isbn', '>= 1.0')
+  spec.add_dependency('hpricot', '>= 0.6')
+  spec.add_dependency('builder', '>= 2.1.2')
   spec.author = "James Healy"
 	spec.email = "jimmy@deefa.com"
 	spec.rubyforge_project = "rbook"

data/examples/header.xml

@@ -0,0 +1,55 @@
+<?xml version='1.0'?>
+<!DOCTYPE ONIXMessage SYSTEM "http://www.editeur.org/onix/2.1/reference/onix-international.dtd">
+<ONIXMessage>
+  <Header>
+    <FromCompany>Chalice</FromCompany>
+    <FromPerson>James Healy</FromPerson>
+    <SentDate>20060521</SentDate>
+  </Header>
+  <Product>
+    <RecordReference>0827200528</RecordReference>
+    <NotificationType>03</NotificationType>
+    <ProductIdentifier>
+      <ProductIDType>02</ProductIDType>
+      <IDValue>0827200528</IDValue>
+    </ProductIdentifier>
+    <ProductForm>BA</ProductForm>
+    <NoSeries/>
+    <Title>
+      <TitleType>01</TitleType>
+      <TitleText>And Their Eyes Are Opened</TitleText>
+      <Subtitle>Story Sermons Embracing the World</Subtitle>
+    </Title>
+    <Contributor>
+      <SequenceNumber>0</SequenceNumber>
+      <ContributorRole>A01</ContributorRole>
+      <PersonNameInverted>Healy, James</PersonNameInverted>
+    </Contributor>
+    <NoEdition/>
+    <BICMainSubject>YFH</BICMainSubject>
+    <MediaFile>
+      <MediaFileTypeCode>04</MediaFileTypeCode>
+      <MediaFileLinkTypeCode>01</MediaFileLinkTypeCode>
+      <MediaFileLink>http://www.example.com/0827200528.jpg</MediaFileLink>
+    </MediaFile>
+    <NumberOfPages>0</NumberOfPages>
+    <Publisher>
+      <PublishingRole>01</PublishingRole>
+      <PublisherName>Chalice</PublisherName>
+    </Publisher>
+    <PublicationDate>20050303</PublicationDate>
+    <SalesRestriction>
+      <SalesRestrictionType>00</SalesRestrictionType>
+      <SalesRestrictionDetail>Unknown</SalesRestrictionDetail>
+    </SalesRestriction>
+    <SupplyDetail>
+      <SupplierName>Chalice</SupplierName>
+      <AvailabilityCode>CS</AvailabilityCode>
+      <IntermediaryAvailabilityCode>99</IntermediaryAvailabilityCode>
+      <Price>
+        <PriceTypeCode>02</PriceTypeCode>
+        <PriceAmount>29.95</PriceAmount>
+      </Price>
+    </SupplyDetail>
+  </Product>
+</ONIXMessage>

data/examples/message.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'rbook/onix'
+
+msg = RBook::Onix::Message.load_from_string(File.read(File.dirname(__FILE__)+"/../specs/data/2_products_utf16.xml"))
+
+puts msg.inspect

data/examples/stream_reader.rb

@@ -1,8 +1,9 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 
+require 'rubygems'
 require 'rbook/onix'
 
-reader = RBook::Onix::StreamReader.new(File.dirname(__FILE__)+"/../specs/data/chalice.xml")
+reader = RBook::Onix::StreamReader.new(File.dirname(__FILE__)+"/../specs/data/eerdsman.xml")
 counter = 0
 
 reader.each do |product|

data/lib/rbook/onix.rb

@@ -10,6 +10,7 @@ require 'rbook/onix/xchar'
 require 'rbook/onix/stream_reader'
 require 'rbook/onix/stream_writer'
 require 'rbook/isbn'
+require 'builder'
 
 module RBook
 

data/lib/rbook/onix/contributor.rb

@@ -1,4 +1,6 @@
 require 'rexml/document'
+require 'hpricot'
+require 'active_support'
 
 module RBook
 module Onix
@@ -6,59 +8,55 @@ module Onix
   class Contributor
     attr_accessor :sequence_number, :role, :name, :name_inverted
 
-    # Attempts to create a contributor object using the supplied xml element
-    def Contributor.load_from_element(element)
-      raise ArgumentError, 'load_from_element expects a REXML element object' unless element.class == REXML::Element
-      
-      if REXML::XPath.first(element, '//Contributor').nil? 
-        raise LoadError, 'supplied REXML document object does not appear contain a valid contributor fragment'
-      end
-      
+    def Contributor.load_from_string(str)
+      doc = Hpricot::XML(str)
       contributor = Contributor.new
 
-      tmp = REXML::XPath.first(element, '//Contributor/SequenceNumber')
-      contributor.sequence_number = tmp.text if tmp != nil
+      tmp = doc.search('//Contributor/sequencenumber')
+      contributor.sequence_number = tmp.inner_html unless tmp.inner_html.blank?
 
-      tmp = REXML::XPath.first(element, '//Contributor/ContributorRole')
-      contributor.role = tmp.text if tmp != nil
+      tmp = doc.search('//Contributor/contributorrole')
+      contributor.role = tmp.inner_html unless tmp.inner_html.blank?
 
-      tmp = REXML::XPath.first(element, '//Contributor/PersonName')
-      contributor.name = tmp.text if tmp != nil
+      tmp = doc.search('//Contributor/personname')
+      contributor.name = tmp.inner_html unless tmp.inner_html.blank?
       
-      tmp = REXML::XPath.first(element, '//Contributor/PersonNameInverted')
-      contributor.name_inverted = tmp.text if tmp != nil
+      tmp = doc.search('//Contributor/personnameinverted')
+      contributor.name_inverted = tmp.inner_html unless tmp.inner_html.blank?
 
       return contributor
-
     end
- 
-    # Return an xml element representing this contributor
-    def to_element
-      raise 'Contributor must have a sequence number to create an element' if @sequence_number.nil?
-      raise 'Contributor must have a role to create an element' if @role.nil?
-      raise '' if @name_inverted.nil? && @name.nil?
-      
-      contributor =  REXML::Element.new('Contributor') 
-      contributor.add_element('SequenceNumber').text = self.sequence_number
-      contributor.add_element('ContributorRole').text = self.role.to_xs
-      contributor.add_element('PersonName').text = name.to_xs unless self.name.nil?
-      contributor.add_element('PersonNameInverted').text = self.name_inverted.to_xs unless self.name_inverted.nil?
+
+    # Attempts to create a contributor object using the supplied xml element
+    # WARNING: deprecated method
+    def Contributor.load_from_element(element)
+      raise ArgumentError, 'load_from_element expects a REXML element object' unless element.class == REXML::Element
       
-      return contributor
+      if REXML::XPath.first(element, '//Contributor').nil? 
+        raise LoadError, 'supplied REXML document object does not appear contain a valid contributor fragment'
+      end
+
+      self.load_from_string(element.to_s)
     end
  
     # Return an XML string representing this contributor
     def to_s
-      output = ''
+      raise 'Contributor must have a sequence number to create an element' if @sequence_number.nil?
+      raise 'Contributor must have a role to create an element' if @role.nil?
+      raise '' if @name_inverted.nil? && @name.nil?
+
+      builder = Builder::XmlMarkup.new(:indent => 2)
 
-      # handle the REXML API change in 1.8.6.110. bah!
-      if RUBY_VERSION >= "1.8.6" && RUBY_PATCHLEVEL >= 110
-        formatter = REXML::Formatters::Pretty.new( 2 )
-        formatter.write( to_element , output )
-      else
-        to_element.write(output, 0)
+      builder.Contributor do |c|
+        c.SequenceNumber  self.sequence_number
+        c.ContributorRole self.role
+        c.PersonName self.name unless self.name.nil?
+        c.PersonNameInverted self.name_inverted unless self.name_inverted.nil?
       end
-      return output
+    end
+
+    def to_element
+      REXML::Document.new(to_s).root
     end
   end
 end

data/lib/rbook/onix/message.rb

@@ -1,4 +1,5 @@
 require 'rexml/document'
+require 'rexml/formatters/transitive'
 
 module RBook
   module Onix
@@ -21,52 +22,65 @@ module RBook
       # Attempts to create a message object using thge supplied xml string
       def self.load_from_string(str)
         self.check_ruby_version
+
+        # attempt to pass the string through REXML, which will auto convert it
+        # to UTF-8 for us. If the file is invalid XML, then still attempt to use
+        # HPricot to parse it, as some data may be extractable
         begin
-          doc = REXML::Document.new(str)
-          self.load_from_xmldoc(doc)
-        rescue REXML::ParseException => e
-          raise LoadError, e.message
+          rexml_doc = REXML::Document.new(str)
+        rescue REXML::ParseException
+          # do nothin
         end
-      end
 
-      # Attempts to create a message object using thge supplied xml document
-      def self.load_from_xmldoc(doc)
-        self.check_ruby_version
-        raise ArgumentError, 'load_from_xmldoc expects a REXML document object' unless doc.class == REXML::Document
-        if REXML::XPath.first(doc, '/ONIXMessage/').nil? ||
-          REXML::XPath.first(doc, '/ONIXMessage/Header').nil? ||
-          REXML::XPath.first(doc, '/ONIXMessage/Product').nil?
-          raise LoadError, 'supplied REXML document object does not appear to be a valid ONIX file'
+        if rexml_doc
+          doc = Hpricot::XML(rexml_doc.to_s)
+        else
+          doc = Hpricot::XML(str)
         end
 
         msg = Onix::Message.new
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromCompany')
-        msg.from_company = tmpelement.text if tmpelement != nil
+        tmp = doc.search('/ONIXMessage/Header/FromCompany')
+        msg.from_company = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromPerson')
-        msg.from_person = tmpelement.text if tmpelement != nil
+        tmp = doc.search('/ONIXMessage/Header/FromPerson')
+        msg.from_person = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromEmail')
-        msg.from_email = tmpelement.text if tmpelement != nil
+        tmp = doc.search('/ONIXMessage/Header/FromEmail')
+        msg.from_email = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/SentDate')
-        tmpdate = Date.civil(tmpelement.text[0,4].to_i, tmpelement.text[4,2].to_i, tmpelement.text[6,2].to_i) if tmpelement != nil
-        msg.sent_date = tmpdate if tmpdate != nil
+        tmp = doc.search('/ONIXMessage/Header/SentDate')
+        if !tmp.inner_html.blank? && tmp.inner_html.length == 8
+          tmpdate = Date.civil(tmp.inner_html[0,4].to_i, tmp.inner_html[4,2].to_i, tmp.inner_html[6,2].to_i)
+          msg.sent_date = tmpdate unless tmpdate.nil?
+        end
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/ToCompany')
-        msg.to_company = tmpelement.text if tmpelement != nil
+        tmp = doc.search('/ONIXMessage/Header/ToCompany')
+        msg.to_company = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/ToPerson')
-        msg.to_person = tmpelement.text if tmpelement != nil
+        tmp = doc.search('/ONIXMessage/Header/ToPerson')
+        msg.to_person = tmp.inner_html unless tmp.inner_html.blank?
 
-        products =  REXML::XPath.each(doc, '/ONIXMessage/Product') { |product|
-          msg.add_product(Onix::Product.load_from_element(product))
-        }
+        doc.search('/ONIXMessage/Product').each do |product|
+          msg.add_product(Onix::Product.load_from_string("<Product>#{product}</Product>"))
+        end
 
         return msg
       end
 
+      # Attempts to create a message object using thge supplied xml document
+      def self.load_from_xmldoc(doc)
+        self.check_ruby_version
+        raise ArgumentError, 'load_from_xmldoc expects a REXML document object' unless doc.class == REXML::Document
+        if REXML::XPath.first(doc, '/ONIXMessage/').nil? ||
+          REXML::XPath.first(doc, '/ONIXMessage/Header').nil? ||
+          REXML::XPath.first(doc, '/ONIXMessage/Product').nil?
+          raise LoadError, 'supplied REXML document object does not appear to be a valid ONIX file'
+        end
+
+        self.load_from_string(doc.to_s)
+      end
+
       # Adds a new product to this message
       def add_product(product)
         raise ArgumentError, 'Argument must be a Onix::Product' if product.class != Onix::Product
@@ -75,51 +89,38 @@ module RBook
 
       # Returns an XML string representing this message
       def to_s
-        doc = to_xml
-        output = ''
-        # stupid hack, because the ruby release mangers imported a broken REXML for this patchset
-        if RUBY_VERSION == "1.8.6" && (RUBY_PATCHLEVEL == 110 || RUBY_PATCHLEVEL == 111)
-         doc.write(output,-1)
-        else
-          doc.write(output,0)
-        end
-        return output
-      end
-    
-      def header
         raise 'from_compnay must be set to create an onix message' if from_company == nil
         raise 'from_person must be set to create an onix message' if from_person == nil
-
-        header = REXML::Element.new('Header')
-        header.add_element('FromCompany').text = from_company.to_xs
-        header.add_element('FromPerson').text = from_person.to_xs
-        header.add_element('FromEmail').text = from_email.to_xs unless from_email.nil?
-        header.add_element('MessageNote').text = message_note.to_xs unless message_note.nil?
-        header.add_element('ToCompany').text = to_company.to_xs unless to_company.nil?
-        header.add_element('ToPerson').text = to_person.to_xs unless to_person.nil?
-
-        now = Time.now
-        header.add_element('SentDate').text = "%.4d%.2d%.2d" % [ now.year, now.month, now.day ]
-        return header
+        raise 'at least one product must be added create an onix message' if @products.size == 0
+
+        builder = Builder::XmlMarkup.new(:indent => 2)
+        builder.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+        builder.declare!  :DOCTYPE, :ONIXMessage, :SYSTEM, "http://www.editeur.org/onix/2.1/reference/onix-international.dtd"
+        builder.ONIXMessage do |msg|
+          msg << self.header
+          @products.each do |product|
+            msg << product.to_s 
+          end
+        end
       end
-      
-      # Returns an XML document representing this message
-      def to_xml
-        raise 'There must be at least 1 product to burn' if @products.size < 1
 
-        doc = REXML::Document.new
-        doc << REXML::XMLDecl.new("1.0", "UTF-8")
-        doc << REXML::DocType.new('ONIXMessage', "SYSTEM \"#{ONIX_DTD_URL}\"")
-        msg = doc.add_element('ONIXMessage')
-        msg.add_element(header)
+      def to_xml
+        REXML::Document.new(to_s)
+      end
 
-        @products.each do |product|
-          prod = msg.add_element(product.to_element)
+      def header
+        builder = Builder::XmlMarkup.new(:indent => 2)
+        builder.Header do |h|
+          h.FromCompany @from_company  if @from_company
+          h.FromPerson @from_person    if @from_person
+          h.FromEmail @from_email      if @from_email
+          h.message_note @message_note if @message_note
+          h.SentDate @sent_date        if @sent_date
+          h.ToPerson @to_person        if @to_person
+          h.ToCompany @to_company      if @to_company
         end
-
-        return doc
       end
-
+    
     end
 
   end

data/lib/rbook/onix/product.rb

@@ -1,4 +1,6 @@
 require 'rexml/document'
+require 'hpricot'
+require 'active_support'
 
 module RBook
   module Onix
@@ -16,76 +18,88 @@ module RBook
         @sales_restrictions = []
       end
 
-      # Attempts to create a product object using the supplied xml element
-      def Product.load_from_element(element)
-        raise ArgumentError, 'load_from_element expects a REXML element object' unless element.class == REXML::Element
-
-        if REXML::XPath.first(element, '//Product').nil? 
-          raise LoadError, 'supplied REXML document object does not appear contain a valid product fragment'
-        end
-
+      # Attempts to create a product object using the supplied xml fragment
+      def Product.load_from_string(str)
+        doc = Hpricot::XML(str)
+        
         product = Product.new
 
-        tmp = REXML::XPath.first(element, '//Product/RecordReference')
-        product.record_reference = tmp.text if tmp != nil
+        tmp = doc.search("//Product/recordreference")
+        product.record_reference = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/NotificationType')
-        product.notification_type = tmp.text if tmp != nil
+        tmp = doc.search("//Product/notificationtype")
+        product.notification_type = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/ProductIdentifier/IDValue')
-        product.product_identifier = tmp.text if tmp != nil
+        tmp = doc.search("//Product/productidentifier/idvalue").first
+        product.product_identifier = tmp.inner_html  unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/ProductForm')
-        product.form = tmp.text if tmp != nil
+        tmp = doc.search("//Product/productform")
+        product.form = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/NumberOfPages')
-        product.pages = tmp.text if tmp != nil
+        tmp = doc.search("//Product/numberofpages")
+        product.pages = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/BICMainSubject')
-        product.bicmainsubject = tmp.text if tmp != nil
+        tmp = doc.search("//Product/bicmainsubject")
+        product.bicmainsubject = tmp.inner_html unless tmp.inner_html.blank?
 
-        REXML::XPath.each(element, '//Product/MediaFile') { |mediafile|
-          type = REXML::XPath.first(element, '//Product/MediaFile/MediaFileTypeCode')
+        doc.search("//Product/mediafile").each do |mediafile|
+          type = doc.search('//Product/mediafile/mediafiletypecode')
           # cover image
-          if type.text.eql?("04")
-            url = REXML::XPath.first(element, '//Product/MediaFile/MediaFileLink')
-            product.cover_image = url.text unless url.nil?
+          if type.inner_html.eql?("04")
+            url = doc.search('//Product/mediafile/mediafilelink')
+            product.cover_image = url.inner_html unless url.inner_html.blank?
           end
-        }
+        end
 
-        tmp = REXML::XPath.first(element, '//Product/DistinctiveTitle')
-        if !tmp.nil?
-          product.title = tmp.text
-          tmp = REXML::XPath.first(element, '//Product/Subtitle') if !tmp.nil?
-          product.subtitle = tmp.text
+        tmp = doc.search("//Product/distinctivetitle")
+        if !tmp.inner_html.blank?
+          product.title = tmp.inner_html
+          tmp = doc.search('//Product/subtitle')
+          product.subtitle = tmp.inner_html unless tmp.inner_html.blank?
         else
-          tmp = REXML::XPath.first(element, '//Product/Title/TitleText')
-          product.title = tmp.text unless tmp.nil?
-          tmp = REXML::XPath.first(element, '//Product/Title/Subtitle')
-          product.subtitle = tmp.text unless tmp.nil?
+          tmp = doc.search('//Product/title/titletext')
+          product.title = tmp.inner_html unless tmp.inner_html.blank?
+          tmp = doc.search('//Product/title/subtitle')
+          product.subtitle = tmp.inner_html unless tmp.inner_html.blank?
         end
 
-        tmp = REXML::XPath.first(element, '//Product/EditionNumber')
-        product.edition = tmp.text if tmp != nil
+        tmp = doc.search('//Product/editionnumber')
+        product.edition = tmp.inner_html unless tmp.inner_html.blank?
 
-        tmp = REXML::XPath.first(element, '//Product/PublicationDate')
-        tmpdate = Date.civil(tmp.text[0,4].to_i, tmp.text[4,2].to_i, tmp.text[6,2].to_i) if tmp != nil
-        product.publication_date = tmpdate if tmpdate != nil
+        tmp = doc.search('//Product/publicationdate')
 
-        tmp = REXML::XPath.first(element, '//Product/Publisher/PublisherName')
-        product.publisher = tmp.text if tmp != nil
+        if !tmp.inner_html.blank? && tmp.inner_html.length == 8 
+          tmpdate = Date.civil(tmp.inner_html[0,4].to_i, tmp.inner_html[4,2].to_i, tmp.inner_html[6,2].to_i)
+          product.publication_date = tmpdate unless tmpdate.nil?
+        end
 
-        REXML::XPath.each(element, '//Product/Contributor') { |contributor|
-          product.add_contributor(Onix::Contributor.load_from_element(contributor))
-        }
+        tmp = doc.search('//Product/publisher/publishername')
+        product.publisher = tmp.inner_html unless tmp.inner_html.blank?
 
-        REXML::XPath.each(element, '//Product/SupplyDetail') { |detail|
-          product.add_supply_detail(Onix::SupplyDetail.load_from_element(detail))
-        }
+        doc.search('//Product/contributor').each do |contributor|
+          product.add_contributor(Onix::Contributor.load_from_string("<contributor>#{contributor}</contributor>"))
+        end
+
+        doc.search('//Product/supplydetail').each do |detail|
+          product.add_supply_detail(Onix::SupplyDetail.load_from_string("<SupplyDetail>#{detail}</SupplyDetail>"
+          ))
+        end
 
         return product
       end
 
+      # Attempts to create a product object using the supplied xml element
+      # WARNING: Deprecated method
+      def Product.load_from_element(element)
+        raise ArgumentError, 'load_from_element expects a REXML element object' unless element.class == REXML::Element
+
+        if REXML::XPath.first(element, '//Product').nil? 
+          raise LoadError, 'supplied REXML document object does not appear contain a valid product fragment'
+        end
+
+        self.load_from_string(element.to_s)
+      end
+
       # Add a new contributor to this product
       def add_contributor(newAuthor)
         raise ArgumentError, 'Argument to add_contributor must be an ONIX::Contributor' if newAuthor.class != Contributor
@@ -104,110 +118,100 @@ module RBook
         @supply_details << detail
       end
 
-      # Return an xml element representing this contributor
-      def to_element
+      # return an XML string representing this contributor
+      def to_s
         raise 'product_identifier must be set' if self.product_identifier.nil?
 
-        product = REXML::Element.new('Product')
+        builder = Builder::XmlMarkup.new(:indent => 2)
+        builder.Product do |p|
 
-        if self.record_reference
-          product.add_element('RecordReference').text = self.record_reference
+        if @record_reference
+          p.RecordReference self.record_reference
         else
-          product.add_element('RecordReference').text = self.product_identifier
+          p.RecordReference self.product_identifier
         end
 
-        product.add_element('NotificationType').text = '03'
+        p.NotificationType '03'
 
-        product_identifier = REXML::Element.new('ProductIdentifier')
-        if ISBN::valid_isbn13?(self.product_identifier)
-          product_identifier.add_element('ProductIDType').text = '03'
-        elsif ISBN::valid_isbn10?(self.product_identifier)
-          product_identifier.add_element('ProductIDType').text = '02'
-        else
-          product_identifier.add_element('ProductIDType').text = '01'
+        p.ProductIdentifier do |id|
+          if ISBN::valid_isbn13?(self.product_identifier)
+            p.ProductIDType '03'
+          elsif ISBN::valid_isbn10?(self.product_identifier)
+            p.ProductIDType '02'
+          else
+            p.ProductIDType '01'
+          end
+          p.IDValue self.product_identifier
         end
-        product_identifier.add_element('IDValue').text = self.product_identifier.to_xs
-        product.add_element(product_identifier)
 
-        if form != nil
-          product.add_element('ProductForm').text = self.form.to_xs
-        end
+        p.ProductForm self.form
 
-        product.add_element('NoSeries')
+        p.NoSeries
 
         title = REXML::Element.new('Title')
-        title.add_element('TitleType').text = '01'
-        title.add_element('TitleText').text = self.title.to_xs unless self.title.nil?
-        title.add_element('Subtitle').text = self.subtitle.to_xs unless self.subtitle.nil?
-        product.add_element(title)
+        p.Title do |t|
+          t.TitleType '01'
+          t.TitleText self.title   unless self.title.nil?
+          t.Subtitle self.subtitle unless self.subtitle.nil?
+        end
 
         if website != nil
-          product_website = REXML::Element.new('Website')
-          product_website.add_element('WebsiteLink').text = self.website.to_xs
-          product.add_element(product_website)
+          p.Website do |w|
+            w.WebsiteLink self.website
+          end
         end
 
         unless cover_image.nil?
-          product_mf = REXML::Element.new('MediaFile')
-          product_mf.add_element('MediaFileTypeCode').text = "04"
-          product_mf.add_element('MediaFileLinkTypeCode').text = "01"
-          product_mf.add_element('MediaFileLink').text = self.cover_image.to_xs
-          product.add_element(product_mf)
+          p.MediaFile do |m|
+            m.MediaFileTypeCode "04"
+            m.MediaFileLinkTypeCode "01"
+            m.MediaFileLink self.cover_image
+          end
         end
 
         contributors.each do |contributor|
-          product.add_element(contributor.to_element)
+          p << contributor.to_s
         end
 
-        product.add_element('NoEdition')
+        p.NoEdition
 
-        product.add_element('NumberOfPages').text = self.pages.to_s unless self.pages.nil?
+        p.NumberOfPages self.pages.to_s unless self.pages.nil?
 
         if bicmainsubject != nil
-          product.add_element('BICMainSubject').text = self.bicmainsubject.to_xs
+          p.BICMainSubject = self.bicmainsubject
         end
 
         if description != nil
-          other_text = REXML::Element.new('OtherText')
-          other_text.add_element('TextTypeCode').text = '01'
-          other_text.add_element('Text').text = self.description.to_xs
-          product.add_element(other_text)
+          p.OtherText do |t|
+            t.TextTypeCode '01'
+            t.Text self.description
+          end
         end
 
         if publisher != nil
-          publisher = REXML::Element.new('Publisher')
-          publisher.add_element('PublishingRole').text = '01'
-          publisher.add_element('PublisherName').text = self.publisher.to_xs
-          product.add_element(publisher)
+          p.Publisher do |pub|
+            pub.PublishingRole '01'
+            pub.PublisherName self.publisher
+          end
         end
 
         supply_details.each do |detail|
-          product.add_element(detail.to_element)
+          p << detail.to_s
         end
 
         sales_restrictions.each do |restriction|
-          product.add_element(restriction.to_element)
+          p << restriction.to_s
         end
 
         if publication_date != nil
-          product.add_element('PublicationDate').text = "%.4d%.2d%.2d" % [ publication_date.year, publication_date.month, publication_date.day ]
+          p.PublicationDate("%.4d%.2d%.2d" % [ publication_date.year, publication_date.month, publication_date.day ])
         end
 
-        return product
+        end
       end
 
-      # return an XML string representing this contributor
-      def to_s
-        output = ''
-
-        # handle the REXML API change in 1.8.6.110. bah!
-        if RUBY_VERSION >= "1.8.6" && RUBY_PATCHLEVEL >= 110
-          formatter = REXML::Formatters::Pretty.new( 2 )
-          formatter.write( to_element , output )
-        else
-          to_element.write(output, 0)
-        end
-        return output
+      def to_element
+        REXML::Document.new(to_s).root
       end
     end