cacofonix 0.10.0

data/lib/cacofonix/core/header.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+module Cacofonix
+  class Header
+    include ROXML
+
+    xml_name "Header"
+
+    xml_accessor :from_ean_number, :from => "FromEANNumber"
+    xml_accessor :from_san,        :from => "FromSAN"
+    xml_accessor :sender_identifiers, :from => "SenderIdentifier", :as => [Cacofonix::SenderIdentifier]
+    xml_accessor :from_company,    :from => "FromCompany"
+    xml_accessor :from_person,     :from => "FromPerson"
+    xml_accessor :from_email,      :from => "FromEmail"
+    xml_accessor :to_ean_number,   :from => "ToEANNumber"
+    xml_accessor :to_san,          :from => "ToSAN"
+    xml_accessor :addressee_identifiers, :from => "AddresseeIdentifier", :as => [Cacofonix::AddresseeIdentifier]
+    xml_accessor :to_company,      :from => "ToCompany"
+    xml_accessor :to_person,       :from => "ToPerson"
+    xml_accessor :message_number,  :from => "MessageNumber"
+    xml_accessor :message_repeat,  :from => "MessageRepeat", :as => Integer
+    xml_accessor(:sent_date,       :from => "SentDate", :to_xml => Cacofonix::Formatters.yyyymmdd) do |val|
+      begin
+        Date.parse(val)
+      rescue
+        nil
+      end
+    end
+    xml_accessor :message_note,    :from => "MessageNote"
+
+    # defaults
+    xml_accessor  :default_language_of_text, :from => "DefaultLanguageOfText"
+    xml_accessor  :default_price_type_code, :from => "DefaultPriceTypeCode", :as => Integer, :to_xml => Cacofonix::Formatters.two_digit
+    xml_accessor  :default_currency_code,   :from => "DefaultCurrencyCode"
+    xml_reader    :default_linear_unit,     :from => "DefaultLinearUnit"        # deprecated in ONIX spec
+    xml_reader    :default_weight_unit,     :from => "DefaultWeightUnit"        # deprecated in ONIX spec
+    xml_accessor  :default_class_of_trade,  :from => "DefaultClassOfTrade"
+
+    def initialize
+      self.sender_identifiers = []
+      self.addressee_identifiers = []
+    end
+  end
+
+end

data/lib/cacofonix/core/lists.rb

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+module Cacofonix
+
+  # Builds hashes for all code lists in the ONIX spec.
+  #
+  # Use like so:
+  #
+  #   Cacofonix::Lists.list(7)
+  #   => { "BB" => "Hardback", ... }
+  #
+  # There are also some constants for commonly used lists:
+  #
+  #   Cacofonix::Lists::PRODUCT_FORM
+  #   => { "BB" => "Hardback", ... }
+  #
+  class Lists
+    include Singleton
+
+    # retrieve a hash with the specified code list
+    #
+    #  Cacofonix::Lists.list(7)
+    #  => { "BB" => "Hardback", ... }
+    #
+    def self.list(number)
+      self.instance.list(number)
+    end
+
+    # Return a hash with the data for a single code list.
+    #
+    # Number should be a fixnum specifying the list to retrieve:
+    #
+    #  Cacofonix::Lists.instance.list(7)
+    #  => { "BB" => "Hardback", ... }
+    #
+    def list(number)
+      raise "Invalid list number: #{number}"  unless number.to_s.match(/^\d+$/)
+      require File.join("cacofonix", "codelists", number.to_s.rjust(3, "0"))
+      eval("Cacofonix::CodeLists::LIST_#{number}")
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.audience_code
+      self.instance.list(28)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.contributor_role
+      self.instance.list(17)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.country_code
+      self.instance.list(91)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.language_code
+      self.instance.list(74)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.language_role
+      self.instance.list(22)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.notification_type
+      self.instance.list(1)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.product_availability
+      self.instance.list(65)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.product_form
+      self.instance.list(7)
+    end
+
+    # Shortcut to retrieve a common code list
+    #
+    def self.product_form_detail
+      self.instance.list(78)
+    end
+
+    # These are here for backwards compatability with the onix gem <= 0.8.3
+    AUDIENCE_CODE        = Cacofonix::Lists.audience_code
+    CONTRIBUTOR_ROLE     = Cacofonix::Lists.contributor_role
+    COUNTRY_CODE         = Cacofonix::Lists.country_code
+    LANGUAGE_CODE        = Cacofonix::Lists.language_code
+    LANGUAGE_ROLE        = Cacofonix::Lists.language_role
+    NOTIFICATION_TYPE    = Cacofonix::Lists.notification_type
+    PRODUCT_AVAILABILITY = Cacofonix::Lists.product_availability
+    PRODUCT_FORM         = Cacofonix::Lists.product_form
+    PRODUCT_FORM_DETAIL  = Cacofonix::Lists.product_form_detail
+
+  end
+end

data/lib/cacofonix/core/reader.rb

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+require 'stringio'
+require "cacofonix/dtds"
+
+module Cacofonix
+
+  # This is the primary class for reading data from an ONIX file.
+  #
+  # Each ONIX file should contain a single header, and 1 or more products:
+  #
+  #   reader = Cacofonix::Reader.new("somefile.xml")
+  #
+  #   puts reader.header.inspect
+  #
+  #   reader.each do |product|
+  #     puts product.inspect
+  #   end
+  #
+  # The header will be returned as an Cacofonix::Header object, and the product will
+  # be an Cacofonix::Product.
+  #
+  # The Cacofonix::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 = Cacofonix::Reader.new("somefile.xml", Cacofonix::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 = Cacofonix::Reader.new("somefile.xml", Cacofonix::APAProduct)
+  #
+  #   puts reader.xml_lang
+  #   puts reader.xml_version
+  #
+  # Note that ONIX has 1500 valid named entities (such as –) that can
+  # cause the parser to throw an exception because it doesn't recognise them.
+  # To work around this, the parser loads the ONIX DTD. It generally has to
+  # do this over the internet, which slows parsing considerably. To skip DTD
+  # loading (running the risk of parser exceptions), you can pass an option
+  # to the constructor:
+  #
+  #   reader = Cacofonix::Reader.new("somefile.xml", Cacofonix::Product, :dtd => false)
+  #
+  # For more information, see http://is.gd/p7fHQq
+  #
+  class Reader
+    include Enumerable
+
+    attr_reader :header, :release
+    attr_reader :xml_lang, :xml_version
+
+    # Options:
+    #
+    #    :dtd - if false, then DTD is not loaded before parsing
+    #    :interpret - a module (or an array of modules) that should extend
+    #                 each Product
+    #
+    def initialize(input, product_klass = ::Cacofonix::Product, options = {})
+      @input = input
+      @product_klass = product_klass
+      @options = options || {}
+
+      create_parser
+
+      @release = find_release
+      @header = find_header
+
+      @xml_lang    ||= @reader.lang
+      @xml_version ||= @reader.xml_version.to_f
+    end
+
+    # Iterate over all the products in an ONIX file
+    #
+    def each(&block)
+      @reader.each do |node|
+        if @reader.node_type == 1 && @reader.name == "Product"
+          str = @reader.outer_xml
+          product = str.nil? ? @product_klass.new : @product_klass.from_xml(str)
+          product.interpret @options[:interpret]
+          yield product
+        end
+      end
+    end
+
+    # Assemble all the products in the ONIX file into an array. Obviously this
+    # will chew through memory with very large ONIX files, so use with care.
+    #
+    def products
+      @products ||= [].tap { |prods| each { |prod| prods << prod } }
+    end
+
+    # Rewind the reader so that you can call 'each' again.
+    #
+    def rewind
+      create_parser
+    end
+
+    def close
+      puts "Reader#close is deprecated."
+    end
+
+    private
+
+    def create_parser
+      Cacofonix::DTDs.apply_libxml_env!
+
+      parser_config = lambda { |cfg|
+        cfg.noent
+        cfg.dtdload unless @options[:dtd] == false
+      }
+      if @input.kind_of?(String)
+        @file   = File.open(@input, "r")
+        @reader = Nokogiri::XML::Reader(@file, &parser_config)
+      elsif @input.respond_to?(:read)
+        @reader = Nokogiri::XML::Reader(@input, &parser_config)
+      else
+        raise ArgumentError, "Unable to read from file or IO stream"
+      end
+    end
+
+    def find_release
+      2.times do
+        @reader.read
+        if @reader.node_type == 1 && @reader.name == "ONIXMessage"
+          value = @reader.attributes["release"]
+          if value
+            return BigDecimal(value)
+          else
+            return nil
+          end
+        elsif @reader.node_type == 14
+          return nil
+        end
+      end
+      return nil
+    end
+
+    def find_header
+      100.times do
+        @reader.read
+        if @reader.node_type == 1 &&  @reader.name == "Header"
+          str = @reader.outer_xml
+          if str.nil?
+            return Cacofonix::Header.new
+          else
+            return Cacofonix::Header.from_xml(str)
+          end
+        end
+      end
+      return nil
+    end
+  end
+end

data/lib/cacofonix/core/writer.rb

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+module Cacofonix
+  # The primary way to write a new ONIX file.
+  #
+  # Here's a quick example. The generated file will be nice and boring, as the
+  # header and product objects have no data in them, but you get the idea.
+  #
+  #   File.open("output.xml","w") do |output|
+  #     header = Cacofonix::Header.new
+  #     Cacofonix::Writer.open(output, header) do |writer|
+  #       writer << Cacofonix::Product.new
+  #       writer << Cacofonix::Product.new
+  #     end
+  #   end
+  #
+  # If you prefer, you can build your products using the APAProduct shim layer.
+  #
+  #   File.open("output.xml","w") do |output|
+  #     header = Cacofonix::Header.new
+  #     Cacofonix::Writer.open(output, header) do |writer|
+  #       writer << Cacofonix::APAProduct.new
+  #       writer << Cacofonix::APAProduct.new
+  #     end
+  #   end
+  #
+  # You can also have the writer build and yield the product to you:
+  #
+  #   Cacofonix::Writer.open(output, header, :class => Cacofonix::APAProduct) do |writer|
+  #     writer.product do |product|
+  #       product.title = "Grimm's Fairy Tales"
+  #       product.publication_date = Date.today
+  #     end
+  #     writer.product do |product|
+  #       product.title = "Telling the Truth"
+  #       product.publication_date = Date.today - 7
+  #     end
+  #   end
+  #
+  #
+  # ... which then allows you to use "interpretation modules":
+  #
+  #   module MySetters
+  #     def set_publication_date_to_xmas
+  #       self.publication_date = Date.parse("2001-12-25")
+  #     end
+  #   end
+  #
+  #   Cacofonix::Writer.open(output, header, :interpret => MySetters) do |writer|
+  #     writer.product { |product| product.set_publication_date_to_xmas }
+  #   end
+  #
+  #
+  class Writer
+
+    DOCTYPE = "http://www.editeur.org/onix/2.1/03/reference/onix-international.dtd"
+
+    # Default constructor.
+    def initialize(output, header, options = {})
+      raise ArgumentError, 'msg must be an Cacofonix::Header object' unless header.kind_of?(Cacofonix::Header)
+      @output = output
+      @header = header
+      @options = options
+      @product_klass = @options[:class] || Cacofonix::Product
+      @finished = false
+
+      start_document
+    end
+
+    # deprecated
+    def start_document
+      puts "Cacofonix::StreamWriter#start_document is no longer required"
+    end
+
+    def << (product)
+      unless product.kind_of?(Cacofonix::Product) || product.kind_of?(Cacofonix::SimpleProduct)
+        raise ArgumentError, 'product must be an Cacofonix::Product or Cacofonix::SimpleProduct'
+      end
+      raise "Can't add products to a finished writer" if finished?
+
+      @output.write(product.to_xml.to_s)
+      @output.write("\n")
+    end
+
+    def product
+      raise ArgumentError, "Block required"  unless block_given?
+      product = @product_klass.new
+      product.interpret @options[:interpret]
+      yield product
+      self << product
+    end
+
+    def end_document
+      @output.write("</ONIXMessage>\n")
+      @finished = true
+    end
+
+    def finished?
+      @finished
+    end
+
+    def self.open(output, header, options = {})
+      if block_given?
+        writer = self.new(output, header, options)
+        yield writer
+        writer.end_document
+      else
+        self.new(output, header, options)
+      end
+    end
+
+    private
+
+    def start_document
+      @output.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+      @output.write("<!DOCTYPE ONIXMessage SYSTEM \"#{DOCTYPE}\">\n")
+      @output.write("<ONIXMessage release=\"2.1\">\n")
+      @output.write(@header.to_xml.to_s)
+      @output.write("\n")
+    end
+
+  end
+end

data/lib/cacofonix/elements/addressee_identifier.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+class Cacofonix::AddresseeIdentifier < Cacofonix::Identifier
+  xml_name "AddresseeIdentifier"
+  onix_code_from_list :addressee_id_type, "AddresseeIDType", :list => 44
+end