onix 0.4.0

data/lib/onix/contributor.rb

@@ -0,0 +1,20 @@
+module ONIX
+  class Contributor
+    include ROXML
+
+    xml_accessor :sequence_number,      :from => "SequenceNumber"
+    xml_accessor :contributor_role,     :from => "ContributorRole"
+    xml_accessor :language_code,        :from => "LanguageCode"
+    xml_accessor :sequence_number_within_role,  :from => "SequenceNumberWithinRole"
+    xml_accessor :person_name,          :etext, :from => "PersonName"
+    xml_accessor :person_name_inverted, :etext, :from => "PersonNameInverted"
+    xml_accessor :titles_before_name,   :etext, :from => "TitlesBeforeName"
+    xml_accessor :names_before_key,     :etext, :from => "NamesBeforeKey"
+    xml_accessor :prefix_to_key,        :etext, :from => "PrefixToKey"
+    xml_accessor :key_names,            :etext, :from => "KeyNames"
+    xml_accessor :names_after_key,      :etext, :from => "NamesArterKey"
+    xml_accessor :suffix_to_key,        :etext, :from => "SuffixToKey"
+    xml_accessor :letters_after_names,  :etext, :from => "LettersAfterNames"
+    xml_accessor :titles_after_names,   :etext, :from => "TitlesAfterNames"
+  end
+end

data/lib/onix/date_type.rb

@@ -0,0 +1,54 @@
+require 'date'
+
+module ONIX
+
+  # Internal class representing XML content date binding
+  #
+  # In context:
+  #  <element attribute="XMLAttributeRef">
+  #   XMLYYYYMMDDRef
+  #  </element>
+  class DateType < ROXML::XMLRef # ::nodoc::
+    attr_reader :cdata, :content
+
+    def initialize(accessor, args, &block)
+      super(accessor, args, &block)
+      @content = args.content?
+      @cdata = args.cdata?
+    end
+
+    # Updates the text in the given _xml_ block to
+    # the _value_ provided.
+    def update_xml(xml, value)
+      parent = wrap(xml)
+      add(parent.child_add(LibXML::XML::Node.new_element(name)), value.strftime("%Y%m%d"))
+      xml
+    end
+
+    def value(xml)
+      begin
+        if content
+          value = Date.parse(xml.content.strip)
+        else
+          child = xml.search(name).first
+          value = Date.parse(child.content.strip) if child
+        end
+      rescue ArgumentError
+        value = nil
+      end
+      block ? block.call(value) : value
+    end
+
+    private
+
+    def add(dest, value)
+      if cdata
+        dest.child_add(LibXML::XML::Node.new_cdata(value.to_utf))
+      else
+        dest.content = value.to_utf
+      end
+    end
+  end
+end
+
+ROXML::TypeRegistry.register(:yyyymmdd, ONIX::DateType)

data/lib/onix/etext_type.rb

@@ -0,0 +1,44 @@
+module ONIX
+
+  class ETextType < ROXML::XMLRef # ::nodoc::
+    attr_reader :cdata, :content
+
+    def initialize(accessor, args, &block)
+      super(accessor, args, &block)
+      @content = args.content?
+      @cdata = args.cdata?
+    end
+
+    # Updates the text in the given _xml_ block to
+    # the _value_ provided.
+    def update_xml(xml, value)
+      value = value.to_s.gsub("&","&amp;").gsub("<","&lt;").gsub(">","&gt;")
+      parent = wrap(xml)
+      add(parent.child_add(LibXML::XML::Node.new_element(name)), value)
+      xml
+    end
+
+    def value(xml)
+      if content
+        value = xml.content
+      else
+        child = xml.search(name).first
+        value = child.content if child
+      end
+      value = value.gsub("&amp;","&").gsub("&lt;","<").gsub("&gt;",">") if value
+      block ? block.call(value) : value
+    end
+
+    private
+
+    def add(dest, value)
+      if cdata
+        dest.child_add(LibXML::XML::Node.new_cdata(value.to_utf))
+      else
+        dest.content = value.to_utf
+      end
+    end
+  end
+end
+
+ROXML::TypeRegistry.register(:etext, ONIX::ETextType)

data/lib/onix/header.rb

@@ -0,0 +1,31 @@
+module ONIX
+  class Header
+    include ROXML
+
+    xml_name "Header"
+
+    xml_accessor :from_person,     :etext, :from => "FromPerson"
+    xml_accessor :from_ean_number, :etext, :from => "FromEANNumber"
+    xml_accessor :from_san,        :etext, :from => "FromSAN"
+    xml_accessor :sender_identifiers, [ONIX::SenderIdentifier], :from => "SenderIdentifier"
+    xml_accessor :from_company,    :etext, :from => "FromCompany"
+    xml_accessor :from_email,      :etext, :from => "FromEmail"
+    xml_accessor :to_ean_number,   :etext, :from => "ToEANNumber"
+    xml_accessor :to_san,          :etext, :from => "ToSAN"
+    xml_accessor :addressee_identifier, [ONIX::AddresseeIdentifier], :from => "AddresseeIdentifier"
+    xml_accessor :to_company,      :etext, :from => "ToCompany"
+    xml_accessor :to_person,       :etext, :from => "ToPerson"
+    xml_accessor :message_number,  :etext, :from => "MessageNumber"
+    xml_accessor :message_repeat,  :integer, :from => "MessageRepeat"
+    xml_accessor :sent_date,       :yyyymmdd, :from => "SentDate"
+    xml_accessor :message_note,    :etext, :from => "MessageNote"
+
+    # defaults
+    xml_accessor  :default_language_of_text, :from => "DefaultLanguageOfText"
+    xml_accessor  :default_price_type_code, :integer, :from => "DefaultPriceTypeCode"
+    xml_accessor  :default_currency_code,   :from => "DefaultCurrencyCode"
+    xml_reader    :default_linear_unit,     :from => "DefaultLinearUnit"        # deprecated
+    xml_reader    :default_weight_unit,     :from => "DefaultWeightUnit"        # deprecated
+    xml_accessor  :default_class_of_trade,  :from => "DefaultClassOfTrade"
+  end
+end

data/lib/onix/imprint.rb

@@ -0,0 +1,10 @@
+module ONIX
+  class Imprint
+    include ROXML
+
+    xml_accessor :name_code_type,      :twodigit, :from => "NameCodeType"
+    xml_accessor :name_code_type_name, :etext,    :from => "NameCodeTypeName"
+    xml_accessor :name_code_value,     :etext,    :from => "NameCodeValue"
+    xml_accessor :imprint_name,        :etext,    :from => "ImprintName"
+  end
+end

data/lib/onix/integer_type.rb

@@ -0,0 +1,43 @@
+
+module ONIX
+
+  class IntegerType < ROXML::XMLRef # ::nodoc::
+    attr_reader :cdata, :content
+
+    def initialize(accessor, args, &block)
+      super(accessor, args, &block)
+      @content = args.content?
+      @cdata = args.cdata?
+    end
+
+    # Updates the text in the given _xml_ block to
+    # the _value_ provided.
+    def update_xml(xml, value)
+      parent = wrap(xml)
+      add(parent.child_add(LibXML::XML::Node.new_element(name)), value)
+      xml
+    end
+
+    def value(xml)
+      if content
+        value = xml.content.to_i
+      else
+        child = xml.search(name).first
+        value = child.content.to_i if child
+      end
+      block ? block.call(value) : value
+    end
+
+    private
+
+    def add(dest, value)
+      if cdata
+        dest.child_add(LibXML::XML::Node.new_cdata(value.to_utf))
+      else
+        dest.content = value.to_utf
+      end
+    end
+  end
+end
+
+ROXML::TypeRegistry.register(:integer, ONIX::IntegerType)

data/lib/onix/lists/product_availability.rb

@@ -0,0 +1,30 @@
+module ONIX
+  module Lists
+    # Code list 65
+    PRODUCT_AVAILABILITY = {
+      1  => "Cancelled",
+      10 => "Not Yet Available",
+      11 => "Awaiting Stock",
+      12 => "Not Yet Available, will be POD",
+      20 => "Available",
+      21 => "In Stock",
+      22 => "To Order",
+      23 => "Manufactured on Demand",
+      30 => "Temporarily Unavailable",
+      31 => "Out Of Stock",
+      32 => "Reprinting",
+      33 => "Awaiting Reissue",
+      40 => "Not Available",
+      41 => "Replaced By New Product",
+      42 => "Other Format Available",
+      43 => "No Longer Supplier By Us",
+      44 => "Apply Direct",
+      45 => "Not Sold Seperately",
+      46 => "Withdrawn From Sale",
+      47 => "Remaindered",
+      48 => "Out Of Print, Replaced By POD with Diff ISBN",
+      99 => "Uncertain"
+    }
+  end
+end
+

data/lib/onix/lists/product_form.rb

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

data/lib/onix/media_file.rb

@@ -0,0 +1,11 @@
+module ONIX
+  class MediaFile
+    include ROXML
+
+    xml_accessor :media_file_type_code, :twodigit, :from => "MediaFileTypeCode"
+    xml_accessor :media_file_format_code, :twodigit, :from => "MediaFileFormatCode"
+    xml_accessor :image_resolution, :from => "ImageResolution"
+    xml_accessor :media_file_link_type_code, :twodigit, :from => "MediaFileLinkTypeCode"
+    xml_accessor :media_file_link, :from => "MediaFileLink"
+  end
+end

data/lib/onix/other_text.rb

@@ -0,0 +1,12 @@
+module ONIX
+  class OtherText
+    include ROXML
+
+    xml_accessor :text_type_code, :twodigit, :from => "TextTypeCode"
+    xml_accessor :text_format,    :etext,    :from => "TextFormat"
+    xml_accessor :text,           :etext,    :from => "Text"
+    xml_accessor :text_link_type, :twodigit, :from => "TextLinkType"
+    xml_accessor :text_link,                 :from => "TextLink"
+    xml_accessor :text_author,    :etext,    :from => "TextAuthor"
+  end
+end

data/lib/onix/price.rb

@@ -0,0 +1,16 @@
+module ONIX
+  class Price
+    include ROXML
+
+    xml_accessor :price_type_code, :twodigit, :from => "PriceTypeCode"
+    xml_accessor :price_type_qualifier, :from => "PriceTypeQualifier"
+    xml_accessor :price_type_description, :from => "PriceTypeDescription"
+    xml_accessor :price_per, :from => "PricePer"
+    xml_accessor :minimum_order_qty, :from => "MinimumOrderQuantity"
+    xml_accessor :class_of_trade, :from => "ClassOfTrade"
+    xml_accessor :bic_discount_group_code, :from => "BICDiscountGroupCode"
+    xml_accessor :price_status, :from => "PriceStatus"
+    xml_accessor :price_amount, :from => "PriceAmount"
+    xml_accessor :currency_code, :from => "CurrencyCode"
+  end
+end

data/lib/onix/product.rb

@@ -0,0 +1,30 @@
+module ONIX
+  class Product
+    include ROXML
+
+    xml_name "Product"
+
+    xml_accessor :record_reference, :from => "RecordReference"
+    xml_accessor :notification_type, :twodigit, :from => "NotificationType"
+    xml_accessor :product_identifiers, [ONIX::ProductIdentifier], :from => "ProductIdentifier"
+    xml_accessor :product_form, :from => "ProductForm"
+    xml_accessor :series, :from => "Series"
+    xml_accessor :edition_number, :integer, :from => "EditionNumber"
+    xml_accessor :titles, [ONIX::Title], :from => "Title"
+    xml_accessor :websites, [ONIX::Website], :from => "Website"
+    xml_accessor :contributors, [ONIX::Contributor], :from => "Contributor"
+    xml_accessor :number_of_pages, :integer, :from => "NumberOfPages"
+    xml_accessor :bic_main_subject, :from => "BICMainSubject"
+    xml_accessor :subjects, [ONIX::Subject], :from => "Subject"
+    xml_accessor :text, [ONIX::OtherText], :from => "OtherText"
+    xml_accessor :media_files, [ONIX::MediaFile], :from => "MediaFile"
+    xml_accessor :imprints, [ONIX::Imprint], :from => "Imprint"
+    xml_accessor :publishers, [ONIX::Publisher], :from => "Publisher"
+    xml_accessor :publishing_status, :twodigit, :from => "PublishingStatus"
+    xml_accessor :publication_date, :yyyymmdd, :from => "PublicationDate"
+    xml_accessor :year_first_published, :integer, :from => "YearFirstPublished"
+    xml_accessor :sales_restrictions, [ONIX::SalesRestriction], :from => "SalesRestriction"
+    xml_accessor :supply_details, [ONIX::SupplyDetail], :from => "SupplyDetail"
+
+  end
+end

data/lib/onix/product_identifier.rb

@@ -0,0 +1,8 @@
+module ONIX
+  class ProductIdentifier
+    include ROXML
+
+    xml_accessor :product_id_type, :twodigit, :from => "ProductIDType"
+    xml_accessor :id_value, :from => "IDValue"
+  end
+end

data/lib/onix/publisher.rb

@@ -0,0 +1,11 @@
+module ONIX
+  class Publisher
+    include ROXML
+
+    xml_accessor :publishing_role,      :twodigit, :from => "PublishingRole"
+    xml_accessor :name_code_type,       :twodigit, :from => "NameCodeType"
+    xml_accessor :name_code_type_name,  :etext,    :from => "NameCodeTypeName"
+    xml_accessor :name_code_type_value, :etext,    :from => "NameCodeTypeValue"
+    xml_accessor :publisher_name,       :etext,    :from => "PublisherName"
+  end
+end

data/lib/onix/reader.rb

@@ -0,0 +1,124 @@
+require 'thread'
+require 'timeout'
+require 'stringio'
+
+module ONIX
+
+  # This is the primary class for reading data from an ONIX file, and there's
+  # really not much to it
+  #
+  # Each file should contain a single header, and 1 or more products:
+  #
+  #   reader = ONIX::Reader.new("somefile.xml")
+  #
+  #   puts reader.header.inspect
+  #
+  #   reader.each do |product|
+  #     puts product.inspect
+  #   end
+  #
+  # The header will be returned as an ONIX::Header object, and the product will
+  # be an ONIX::Product.
+  #
+  # The ONIX::Product class can be a bit of a hassle to work with, as data can be
+  # nested in it fairly deeply. To wrap all the products returned by the reader
+  # in a shim that provides simple accessor access to common attributes, pass the
+  # shim class as a second argument
+  #
+  #   reader = ONIX::Reader.new("somefile.xml", ONIX::APAProduct)
+  #
+  #   puts reader.header.inspect
+  #
+  #   reader.each do |product|
+  #     puts product.inspect
+  #   end
+  #
+  # APAProduct stands for Australian Publishers Association and provides simple
+  # access to the ONIX attributes that are commonly used in the Australian market.
+  #
+  # As well as accessing the file header, there are handful of other read only
+  # attributes that might be useful
+  #
+  #   reader = ONIX::Reader.new("somefile.xml", ONIX::APAProduct)
+  #
+  #   puts reader.version
+  #   puts reader.xml_lang
+  #   puts reader.xml_version
+  #   puts reader.encoding
+  #
+  # The version attribute is particuarly useful. There are multiple revisions of the
+  # ONIX spec, and you may need to handle the file differently based on what
+  # version it is.
+  #
+  class Reader
+
+    attr_reader :header, :version, :xml_lang, :xml_version, :encoding
+
+    # Create a new ONIX::Reader object
+    #
+    def initialize(input, product_klass = ::ONIX::Product)
+      if input.kind_of? String
+        @reader = LibXML::XML::Reader.file(input)
+      elsif input.kind_of?(IO)
+        @reader = LibXML::XML::Reader.io(input)
+      else
+        throw "Unable to read from path or file"
+      end
+
+      @product_klass = product_klass
+
+      # create a sized queue to store each product read from the file
+      @queue = SizedQueue.new(100)
+
+      # launch a reader thread to process the file and store each
+      # product in the queue
+      Thread.abort_on_exception = true
+      Thread.new { read_input }
+
+      # TODO: this is a seriously hacky way to ensure the reading thread
+      #       has enough time to read our metadata and header objects from
+      #       the input stream. I should be making the constructor block until
+      #       it has actively confirmed the data has been read
+      sleep 1
+    end
+
+    # Iterate over all the products in an ONIX file
+    #
+    def each(&block)
+      obj = @queue.pop
+      while !obj.nil?
+        yield obj
+        obj = @queue.pop
+      end
+    end
+
+    private
+
+    # Walk the ONIX file, and grab the bits we're interested in.
+    #
+    # High level attributes and the header are stored as attributes of the reader
+    # class. Products are placed in a queue, ready to be popped off when the
+    # user uses the each() method.
+    #
+    def read_input
+      while @reader.read == 1
+        @xml_lang    = @reader.xml_lang         if @xml_lang.nil?
+        @xml_version = @reader.xml_version.to_f if @xml_version.nil?
+        @encoding    = @reader.encoding         if @encoding.nil?
+        if @reader.node_type == 10
+          uri = @reader.expand.to_s
+          m, major, minor, rev = *uri.match(/.+(\d)\.(\d)\/(\d*).*/)
+          @version = [major.to_i, minor.to_i, rev.to_i]
+        elsif @reader.name == "Header" && @reader.node_type == 1
+          @header = ONIX::Header.parse(@reader.expand.to_s)
+          @reader.next_sibling
+        elsif @reader.name == "Product" && @reader.node_type == 1
+          node = @reader.expand
+          @queue.push @product_klass.parse(node.to_s)
+          @reader.next_sibling
+        end
+      end
+      @queue.push nil
+    end
+  end
+end