rbook 0.1

data/lib/rbook/onix.rb

@@ -0,0 +1,68 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../")
+
+require 'rbook/onix/contributor'
+require 'rbook/onix/lists'
+require 'rbook/onix/message'
+require 'rbook/onix/product'
+require 'rbook/onix/sales_restriction'
+require 'rbook/onix/supply_detail'
+require 'rbook/onix/xchar'
+require 'rbook/isbn'
+
+module RBook
+
+  # Ruby classes for working with ONIX files. Currently only supports a very limited
+  # subset of the ONIX specification, but the core attributes are there. More will be
+  # added over time.
+  #
+  # = Usage
+  # 
+  # == Loading from an REXML document
+  # 
+  #   require 'rubygems'
+  #   require 'rbook/onix'
+  #   file = File.open("./onix_message.xml", "r")
+  #   doc = REXML::Document.new(file) 
+  #   msg = Onix::Message.load_from_xmldoc(doc)
+  #  
+  #   puts msg.from_company
+  #  
+  # == Creation
+  #
+  #   require 'rubygems'
+  #   require 'rbook/onix'
+  #   msg = RBook::Onix::Message.new
+  #   msg.from_company = 'XYZ Books'
+  #   msg.from_name = 'Joe Blogs'
+  #   msg.message_note = "A sample ONIX file"
+  #   
+  #   product = RBook::Onix::Product.new
+  #   product.product_identifier = "020161622X"
+  #   product.title = "Pragmatic Programmer"
+  #   product.subtitle = "From Journeyman to Master"
+  #   product.form = "BB"
+  #   product.description = "A book about programming and stuff"
+  #
+  #   contributor1 = RBook::Onix::Contributor.new
+  #   contributor1.name_inverted = "Hunt, Andrew"
+  #   contributor1.role = "A01"
+  #   contributor1.sequence = "01"
+  #   contributor2 = RBook::Onix::Contributor.new
+  #   contributor2.name_inverted = "Thomas, David"
+  #   contributor2.role = "A01"
+  #   contributor2.sequence = "02"
+  #   product.add_contributor(contributor1)
+  #   product.add_contributor(contributor2)
+  #
+  #   supply_detail = RBook::Onix::SupplyDetail.new
+  #   supply_detail.supplier_name = "Rainbow Book Agencies"
+  #   supply_detail.price = BigDecimal.new(29.95)
+  #   supply_detail.availability = "CS"
+  #   product.add_supply_detail(supply_detail)
+  #
+  #   msg.add_product(product)
+  #   puts msg.to_s
+  module Onix
+
+  end
+end

data/lib/rbook/onix/contributor.rb

@@ -0,0 +1,60 @@
+require 'rexml/document'
+require 'rubygems'
+
+module RBook
+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
+      
+      contributor = Contributor.new
+
+      tmp = REXML::XPath.first(element, '//Contributor/SequenceNumber')
+      contributor.sequence_number = tmp.text if tmp != nil
+
+      tmp = REXML::XPath.first(element, '//Contributor/ContributorRole')
+      contributor.role = tmp.text if tmp != nil
+
+      tmp = REXML::XPath.first(element, '//Contributor/PersonName')
+      contributor.name = tmp.text if tmp != nil
+      
+      tmp = REXML::XPath.first(element, '//Contributor/PersonNameInverted')
+      contributor.name_inverted = tmp.text if tmp != nil
+
+      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?
+      
+      return contributor
+    end
+ 
+    # Return an XML string representing this contributor
+    def to_s
+      tmp = to_element
+      output = ''
+      tmp.write(output, 0)
+      return output
+    end
+  end
+end
+end

data/lib/rbook/onix/lists.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lists/contributor_role'
+require File.dirname(__FILE__) + '/lists/product_form'

data/lib/rbook/onix/lists/contributor_role.rb

@@ -0,0 +1,10 @@
+module RBook
+module Onix
+  module Lists
+    CONTRIBUTOR_ROLES = [
+      ['Author','A01'],
+      ['Illustrator','A02']
+    ].freeze
+  end
+end
+end

data/lib/rbook/onix/lists/product_form.rb

@@ -0,0 +1,100 @@
+module RBook
+module Onix
+  module Lists
+    
+  FORM_CODES = [ 
+   ['Undefined', '00'],
+   ['Audio', 'AA'],
+   ['Audio - Cassette', 'AB'],
+   ['Audio - CD', 'AC'],
+   ['Audio - DAT', 'AD'],
+   ['Audio - Disk', 'AE'],
+   ['Audio - Tape', 'AF'],
+   ['Audio - Other', 'AZ'],
+   ['Book', 'BA'],
+   ['Book - Hardback', 'BB'],
+   ['Book - Paperback', 'BC'],
+   ['Book - Loose-leaf', 'BD'],
+   ['Book - Spiral Bound', 'BE'],
+   ['Book - Pamphlet', 'BF'],
+   ['Book - Leather / Fine Binding', 'BG'],
+   ['Book - Board', 'BH'],
+   ['Book - Rag', 'BI'],
+   ['Book - Bath', 'BJ'],
+   ['Book - Other', 'BZ'],
+   ['Cartographic - Sheet Map', 'CA'],
+   ['Cartographic - Sheet Map, Folded', 'CB'],
+   ['Cartographic - Sheet Map, Flat', 'CC'],
+   ['Cartographic - Sheet Map, Rolled', 'CD'],
+   ['Cartographic - Globe', 'CE'],
+   ['Cartographic - Other', 'CZ'],
+   ['Digital', 'DA'],
+   ['Digital - CDROM', 'DB'],
+   ['Digital - CD-Interactive', 'DC'],
+   ['Digital - DVD', 'DD'],
+   ['Digital - Game Cartridge', 'DE'],
+   ['Digital - Diskette', 'DF'],
+   ['Digital - Electronic Book Text', 'DG'],
+   ['Digital - Online File', 'DH'],
+   ['Digital - Other', 'DZ'],
+   ['Film or Transparency', 'FA'],
+   ['Film', 'FB'],
+   ['Film - Slides', 'FC'],
+   ['Film - OHP Transparencies', 'FD'],
+   ['Film - Other ', 'FZ'],
+   ['Microform', 'MA'],
+   ['Microform - Microfiche', 'MB'],
+   ['Microform - Microfilm', 'MC'],
+   ['Microform - Other', 'MZ'],
+   ['Print - Misc', 'PA'],
+   ['Print - Address Book', 'PB'],
+   ['Print - Calendar', 'PC'],
+   ['Print - Cards', 'PD'],
+   ['Print - Copymasters', 'PE'],
+   ['Print - Diary', 'PF'],
+   ['Print - Frieze', 'PG'],
+   ['Print - Kit', 'PH'],
+   ['Print - Sheet Music', 'PI'],
+   ['Print - Postcard Book or Pack', 'PJ'],
+   ['Print - Poster', 'PK'],
+   ['Print - Record Book', 'PL'],
+   ['Print - Wallet', 'PM'],
+   ['Print - Pictures or Photographs', 'PN'],
+   ['Print - Wallchart', 'PO'],
+   ['Print - Other', 'PZ'],
+   ['Video', 'VA'],
+   ['Video - VHS, PAL', 'VB'],
+   ['Video - VHA, NTSC', 'VC'],
+   ['Video - Betamax, PAL', 'VD'],
+   ['Video - Betamax, NTSC', 'VE'],
+   ['Video - disk', 'VF'],
+   ['Video - VHS, SECAM', 'VG'],
+   ['Video - Betamax, SECAM', 'VH'],
+   ['Video -  Other Format','VZ'],
+   ['Multiple - Mixed Media Product', 'WW'],
+   ['Misc - Quantity Pack', 'WX'],
+   ['Misc - Trade-only Material', 'XA'],
+   ['Misc - Dumpbim - Empty', 'XB'],
+   ['Misc - Dumpbin - Filled', 'XC'],
+   ['Misc - Counterpack - Empty', 'XD'],
+   ['Misc - Counterpack - Filled', 'XE'],
+   ['Misc - Poster', 'XF'],
+   ['Misc - Shelf Strip', 'XG'],
+   ['Misc - Window Piece', 'XH'],
+   ['Misc - Streamer', 'XI'],
+   ['Misc - Spinner', 'XJ'],
+   ['Misc - Large Book Display', 'XK'],
+   ['Misc - Shrink Wrapped Pack', 'XL'],
+   ['Misc - Other Point of Sale', 'XZ'],
+   ['General Merchandise', 'ZA'],
+   ['Misc - Doll', 'ZB'],
+   ['Misc - Soft Toy', 'ZC'],
+   ['Misc - Toy', 'ZD'],
+   ['Misc - Game', 'ZE'],
+   ['Misc - T-shirt', 'ZF'],
+   ['Misc - Other Merchandise', 'ZZ'],
+  ].freeze
+
+  end
+  end
+end

data/lib/rbook/onix/message.rb

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'rexml/document'
+
+module RBook
+module Onix
+
+class Message
+  attr_reader :products
+  attr_accessor :from_company, :from_person, :from_email, :message_note, :sent_date, :to_person, :to_company
+  
+  VERSION = 0.1
+
+  def initialize
+    @ONIX_DTD_URL = "http://www.editeur.org/onix/2.1/reference/onix-international.dtd"
+    
+    @products = []
+  end
+
+  # Attempts to create a message object using thge supplied xml document
+  def Message.load_from_xmldoc(doc)
+    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
+    
+    msg = Onix::Message.new
+    
+    tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromCompany')
+    msg.from_company = tmpelement.text if tmpelement != nil
+   
+    tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromPerson')
+    msg.from_person = tmpelement.text if tmpelement != nil
+   
+    tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/FromEmail')
+    msg.from_email = tmpelement.text if tmpelement != nil
+   
+    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
+  
+    tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/ToCompany')
+    msg.to_company = tmpelement.text if tmpelement != nil
+
+    tmpelement = REXML::XPath.first(doc, '/ONIXMessage/Header/ToPerson')
+    msg.to_person = tmpelement.text if tmpelement != nil
+  
+    products =  REXML::XPath.each(doc, '/ONIXMessage/Product') { |product|
+      msg.add_product(Onix::Product.load_from_element(product))
+    }
+  
+    return msg
+  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
+    @products << product
+  end
+
+  # Returns an XML string representing this message
+  def to_s
+    doc = to_xml
+    output = ''
+    doc.write(output, 0)
+    return output
+  end
+
+  # Returns an XML document representing this message
+  def to_xml
+    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
+    raise 'There must be at least 1 product to burn' if @products.size < 1
+  
+    doc = REXML::Document.new
+    doc << REXML::XMLDecl.new
+    doc << REXML::DocType.new('ONIXMessage', "SYSTEM \"#{@ONIX_DTD_URL}\"")
+    msg = doc.add_element('ONIXMessage')
+    header = msg.add_element('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 ]
+    
+    @products.each do |product|
+      prod = msg.add_element(product.to_element)
+    end
+
+    return doc
+  end
+
+end
+
+end
+end

data/lib/rbook/onix/product.rb

@@ -0,0 +1,188 @@
+require 'rexml/document'
+require 'rubygems'
+
+module RBook
+module Onix
+class Product
+
+  attr_accessor :record_reference, :notification_type, :product_identifier, :title, :subtitle, :pages, :publication_date, :price, :description, :form, :bicmainsubject, :publisher, :supplier, :website, :edition
+  attr_reader :contributors, :sales_restrictions, :supply_details
+  
+  def initialize
+    @contributors = []
+    @supply_details = []
+    @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
+    
+    product = Product.new
+    
+    tmp = REXML::XPath.first(element, '//Product/RecordReference')
+    product.record_reference = tmp.text if tmp != nil
+    
+    tmp = REXML::XPath.first(element, '//Product/NotificationType')
+    product.notification_type = tmp.text if tmp != nil
+    
+    # TODO: load ProductIdentifier from the fragment
+    
+    tmp = REXML::XPath.first(element, '//Product/ProductForm')
+    product.form = tmp.text if tmp != nil
+    
+    tmp = REXML::XPath.first(element, '//Product/NumberOfPages')
+    product.pages = tmp.text if tmp != nil
+
+    tmp = REXML::XPath.first(element, '//Product/BICMainSubject')
+    product.bicmainsubject = tmp.text if tmp != nil
+
+    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
+    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?
+    end
+
+    tmp = REXML::XPath.first(element, '//Product/EditionNumber')
+    product.edition = tmp.text if tmp != nil
+
+    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 = REXML::XPath.first(element, '//Product/Publisher/PublisherName')
+    product.publisher = tmp.text if tmp != nil
+
+    REXML::XPath.each(element, '//Product/Contributor') { |contributor|
+      product.add_contributor(Onix::Contributor.load_from_element(contributor))
+    }
+
+    REXML::XPath.each(element, '//Product/SupplyDetail') { |detail|
+      product.add_supply_detail(Onix::SupplyDetail.load_from_element(detail))
+    }
+
+    return product
+  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
+    @contributors << newAuthor
+  end
+
+  # Add a new contributor to this product
+  def add_sales_restriction(restriction)
+    raise ArgumentError, 'Argument to add_sales_restriction must be an ONIX::SalesRestriction' if restriction.class != SalesRestriction
+    @sales_restrictions << restriction
+  end
+  
+  # Add a new contributor to this product
+  def add_supply_detail(detail)
+    raise ArgumentError, 'Argument to add_supply_detail must be an ONIX::SupplyDetail' if detail.class != SupplyDetail
+    @supply_details << detail
+  end
+  
+  # Return an xml element representing this contributor
+  def to_element
+    raise 'product_identifier must be set' if self.product_identifier.nil?
+  
+    product = REXML::Element.new('Product')
+    
+    if self.record_reference
+      product.add_element('RecordReference').text = self.record_reference
+    else
+      product.add_element('RecordReference').text = self.product_identifier
+    end
+
+    product.add_element('NotificationType').text = '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'
+    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
+
+    product.add_element('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)
+
+    if website != nil
+      product_website = REXML::Element.new('Website')
+      product_website.add_element('WebsiteLink').text = self.website.to_xs
+      product.add_element(product_website)
+    end
+    
+    contributors.each do |contributor|
+      product.add_element(contributor.to_element)
+    end
+
+    product.add_element('NoEdition')
+
+    product.add_element('NumberOfPages').text = self.pages.to_s unless self.pages.nil?
+
+    if bicmainsubject != nil
+      product.add_element('BICMainSubject').text = self.bicmainsubject.to_xs
+    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)
+    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)
+    end
+
+    supply_details.each do |detail|
+      product.add_element(detail.to_element)
+    end
+  
+    sales_restrictions.each do |restriction|
+      product.add_element(restriction.to_element)
+    end
+    
+    if publication_date != nil
+      product.add_element('PublicationDate').text = "%.4d%.2d%.2d" % [ publication_date.year, publication_date.month, publication_date.day ]
+    end
+
+    return product
+  end
+
+  # return an XML string representing this contributor
+  def to_s
+    output = ''
+    to_element.write(output, 0)
+    return output
+  end
+end
+
+end
+end