milkfarm-onix 0.7.7

data/lib/onix/reader.rb

@@ -0,0 +1,187 @@
+# coding: utf-8
+
+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
+    include Enumerable
+
+    attr_reader :header , :version, :xml_lang, :xml_version, :encoding
+
+    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
+        raise ArgumentError, "Unable to read from file or IO stream"
+      end
+
+      @product_klass = product_klass
+
+      @header = read_next
+
+      @xml_lang    ||= @reader.xml_lang
+      @xml_version ||= @reader.xml_version.to_f
+      @encoding    ||= encoding_const_to_name(@reader.encoding)
+    end
+
+    # Iterate over all the products in an ONIX file
+    #
+    def each(&block)
+      while obj = read_next
+        yield obj
+      end
+    end
+
+    def close
+      @reader.close if @reader
+    end
+
+    private
+
+    # Walk the ONIX file, and grab the next header or product fragment.
+    #
+    def read_next
+      while @reader.read
+
+        if @reader.node_type == LibXML::XML::Reader::TYPE_DOCUMENT_TYPE
+          # TODO restore ONIX version extraction. The following expand()
+          #      call is triggering unpredictable behaviour in libxml-ruby
+          #      1.1.3 with libxml2 2.7.3. Sometimes segfaults, othertimes
+          #      cryptic errors about the input file being truncated or
+          #      incomplete
+          #uri = @reader.expand.to_s.dup
+          #m, major, minor, rev = *uri.match(/.+(\d)\.(\d)\/(\d*).*/)
+          #@version = [major.to_i, minor.to_i, rev.to_i]
+        elsif @reader.node_type == LibXML::XML::Reader::TYPE_ELEMENT
+          if @reader.name == "Header"
+            str = normalise_string_encoding(@reader.read_outer_xml.to_s.dup)
+            if str.size == 0
+              return ONIX::Header.new
+            else
+              return ONIX::Header.from_xml(str)
+            end
+          elsif @reader.name == "Product"
+            str = normalise_string_encoding(@reader.read_outer_xml.to_s.dup)
+            if str.size == 0
+              return @product_klass.new
+            else
+              return @product_klass.from_xml(str)
+            end
+          end
+        end
+      end
+
+      return nil
+    rescue LibXML::XML::Error => e
+      return nil
+    end
+
+    # XML::Reader seems to transparently convert all input data to utf-8, howver
+    # on Ruby 1.9 it fails to correctly set the encoding on the strings.
+    #
+    def normalise_string_encoding(str)
+      if RUBY_VERSION >= "1.9"
+        return str.dup.force_encoding("utf-8")
+      else
+        str
+      end
+    end
+
+    # simple mapping of encoding constants to a string
+    #
+    def encoding_const_to_name(const)
+      return nil if const.nil?
+      case const
+      when LibXML::XML::Encoding::UTF_8
+        "utf-8"
+      when LibXML::XML::Encoding::UTF_16LE
+        "utf-16le"
+      when LibXML::XML::Encoding::UTF_16BE
+        "utf-16be"
+      when LibXML::XML::Encoding::UCS_4LE
+        "ucs-4le"
+      when LibXML::XML::Encoding::UCS_4BE
+        "ucs-4be"
+      when LibXML::XML::Encoding::UCS_2
+        "ucs-2"
+      when LibXML::XML::Encoding::ISO_8859_1
+        "iso-8859-1"
+      when LibXML::XML::Encoding::ISO_8859_2
+        "iso-8859-2"
+      when LibXML::XML::Encoding::ISO_8859_3
+        "iso-8859-3"
+      when LibXML::XML::Encoding::ISO_8859_4
+        "iso-8859-4"
+      when LibXML::XML::Encoding::ISO_8859_5
+        "iso-8859-5"
+      when LibXML::XML::Encoding::ISO_8859_6
+        "iso-8859-6"
+      when LibXML::XML::Encoding::ISO_8859_7
+        "iso-8859-7"
+      when LibXML::XML::Encoding::ISO_8859_8
+        "iso-8859-8"
+      when LibXML::XML::Encoding::ISO_8859_9
+        "iso-8859-9"
+      when LibXML::XML::Encoding::ISO_2022_JP
+        "iso-2022-jp"
+      when LibXML::XML::Encoding::SHIFT_JIS
+        "shift-jis"
+      when LibXML::XML::Encoding::EUC_JP
+        "euc-jp"
+      when LibXML::XML::Encoding::ASCII
+        "ascii"
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/onix/sales_restriction.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+module ONIX
+  class SalesRestriction
+    include ROXML
+    include ONIX::Common
+
+    xml_name "SalesRestriction"
+
+    xml_accessor :sales_restriction_type, :from =>"SalesRestrictionType", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+  end
+end

data/lib/onix/sender_identifier.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+module ONIX
+  class SenderIdentifier
+    include ROXML
+    include ONIX::Common
+
+    xml_name "SenderIdentifier"
+
+    xml_accessor :sender_id_type, :from => "SenderIDType", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :id_type_name,   :from => "IDTypeName"
+    xml_accessor :id_value,       :from => "IDValue"
+  end
+end

data/lib/onix/series.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+module ONIX
+  class Series
+    include ROXML
+    include ONIX::Common
+
+    xml_name "Series"
+
+    xml_accessor :series_identifiers, :from => "SeriesIdentifier", :as => [ONIX::SeriesIdentifier]
+    xml_accessor :title_of_series, :from => "TitleOfSeries"
+    
+    def initialize
+      self.series_identifiers = []
+    end
+    
+    # retrieve the proprietary series ID
+    def proprietary_series_id
+      series_identifier(1).andand.id_value
+    end
+
+    # set a new proprietary series ID
+    def proprietary_series_id=(id)
+      series_identifier_set(1, id)
+    end
+    
+    # retrieve the issn
+    def issn
+      series_identifier(2).andand.id_value
+    end
+
+    # set a new issn
+    def issn=(id)
+      series_identifier_set(2, id)
+    end
+    
+    # retrieve the value of a particular ID
+    def series_identifier(type)
+      identifier = series_identifiers.find { |id| id.series_id_type == type }
+    end
+
+    # set the value of a particular ID
+    def series_identifier_set(type, value)
+      series_indentifier_id = series_identifiers.find { |id| id.series_id_type == type }
+      
+      # create a new series identifier record if we need to
+      if series_indentifier_id.nil?
+        series_indentifier_id = ONIX::SeriesIdentifier.new
+      end
+      
+      series_indentifier_id.series_id_type = type
+      series_indentifier_id.id_value = value
+      
+      series_identifiers << series_indentifier_id
+    end
+  end
+end

data/lib/onix/series_identifier.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+module ONIX
+  class SeriesIdentifier
+    include ROXML
+    include ONIX::Common
+
+    xml_name "SeriesIdentifier"
+
+    xml_accessor :series_id_type, :from => "SeriesIDType", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :id_value, :from => "IDValue"
+  end
+end

data/lib/onix/simple_product.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module ONIX
+  # super class for some simplified ONIX::Product wrappers
+  class SimpleProduct
+
+    def initialize(product = nil)
+      @product = product || ::ONIX::Product.new
+    end
+
+    class << self
+      
+      include Forwardable
+
+      def from_xml(xml)
+        self.new(::ONIX::Product.from_xml(xml))
+      end
+
+      def parse_file(filename)
+        self.new(::ONIX::Product.parse(File.read(filename)))
+      end
+
+      def parse(xml)
+        self.new(::ONIX::Product.parse(xml))
+      end
+    
+      protected
+
+      def delegate(*args)
+        def_delegators :@product, *args
+      end
+    end
+
+    def product
+      @product
+    end
+
+    def to_xml
+      product.to_xml
+    end
+
+    # TODO: add method missing magic to proxy through to the underlying product?
+
+  end
+end

data/lib/onix/sl_product.rb

@@ -0,0 +1,131 @@
+# coding: utf-8
+
+module ONIX
+  class SLProduct < APAProduct
+
+    delegate :audience_code, :audience_code=
+    delegate :copyright_year, :copyright_year=
+    delegate :product_form_detail, :product_form_detail=
+    
+    alias_method :old_initialize, :initialize
+    def initialize(*args)
+      result = old_initialize(*args)
+      result.audience_code = 4 # Primary & secondary/elementary & high school
+      result
+    end
+    
+    # retrieve the value of a particular ID
+    def series(str)
+      product.series.find { |id| id.title_of_series == str }
+    end
+
+    # set the value of a particular ID
+    def series=(value)
+      # process based on value type
+      if value.is_a?(Series)
+        str = value.title_of_series
+        series_id = value
+      else
+        str = value
+        series_id = ONIX::Series.new
+        series_id.title_of_series = value
+      end
+      # check if exists already
+      unless series(str)
+        product.series << series_id
+      end
+    end
+    
+    # retrieve the "language of text" (role=1) language code for this particular product
+    def language_code
+      language(1).andand.language_code
+    end
+
+    # set a new "language of text" (role=1) language code for this particular product
+    def language_code=(str)
+      language_set(1, str)
+    end
+    
+    # retrieve the "language of text" (role=1) country code for this particular product
+    def country_code
+      language(1).andand.country_code
+    end
+
+    # set a new "language of text" (role=1) country code for this particular product
+    def country_code=(str)
+      language_set(1, language_code, str)
+    end
+    
+    # retrieve the value of a particular language
+    def language(type)
+      product.languages.find { |l| l.language_role == type }
+    end
+
+    # set the value of a particular language
+    def language_set(type, value, value2=nil)
+      l = language(type)
+
+      # create a new language record if we need to
+      if l.nil?
+        l = ONIX::Language.new
+        l.language_role = type
+        product.languages << l
+      end
+
+      # cannot set country_code without language_code
+      unless value.nil?
+        l.language_code = value.to_s # mandatory
+        l.country_code = value2.to_s if value2 # optional
+      end
+    end
+    
+    # retrieve the dewey for this title
+    def dewey
+      product.subjects.find { |sub| sub.subject_scheme_id.to_i == 1 } # dewey = 1, abridged dewey = 2
+    end
+
+    # add a dewey to the product
+    def dewey=(code)
+      add_subject code, "1" # dewey = 1, abridged dewey = 2
+    end
+    
+    # audience_range_qualifier: 11 = US school grades
+    # audience_range_precision: 1 = exact, 3 = from, 4 = to
+    def us_grade_range
+      audience_range(11)
+    end
+
+    # set a new "audience of text" (role=1) country code for this particular product
+    def us_grade_range=(range=[])
+      audience_range_set(11, range[0], range[1])
+    end
+    
+    # retrieve the value of a particular audience range
+    def audience_range(type)
+      product.audience_ranges.find { |a| a.audience_range_qualifier == type }
+    end
+
+    # set the value of a particular audience_range
+    def audience_range_set(type, min=nil, max=nil)
+      a = audience_range(type)
+
+      # create a new audience_range record if we need to
+      if a.nil?
+        a = ONIX::AudienceRange.new
+        a.audience_range_qualifier = type
+        product.audience_ranges << a
+      end
+
+      unless min.nil?
+        a.audience_range_precisions << "03"
+        a.audience_range_values << min
+      end
+      unless max.nil?
+        a.audience_range_precisions << "04"
+        a.audience_range_values << max
+      end
+      a.audience_range_precisions = ["01"] if min.nil? || max.nil?
+    end
+
+  end
+end

data/lib/onix/stock.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+module ONIX
+  class Stock
+    include ROXML
+    include ONIX::Common
+
+    xml_name "Stock"
+
+    # NOTE: these *should* be numeric fields according to the spec,
+    #       but heaps of ONIX files in the wild use text
+    xml_accessor :on_hand, :from => "OnHand"
+    xml_accessor :on_order, :from => "OnOrder"
+  end
+end

data/lib/onix/subject.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+module ONIX
+  class Subject
+    include ROXML
+    include ONIX::Common
+
+    xml_name "Subject"
+
+    xml_accessor :subject_scheme_id,      :from => "SubjectSchemeIdentifier", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :subject_scheme_name,    :from => "SubjectSchemeName"
+    xml_accessor :subject_scheme_version, :from => "SubjectSchemeVersion"
+    xml_accessor :subject_code,           :from => "SubjectCode"
+    xml_accessor :subject_heading_text,   :from => "SubjectHeadingText"
+  end
+end

data/lib/onix/supply_detail.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+module ONIX
+  class SupplyDetail
+    include ROXML
+    include ONIX::Common
+
+    xml_name "SupplyDetail"
+
+    xml_accessor :supplier_ean_location_number, :from => "SupplierEANLocationNumber"
+    xml_accessor :supplier_san, :from => "SupplierSAN"
+    xml_accessor :supplier_name, :from => "SupplierName"
+    xml_accessor :telephone_number, :from => "TelephoneNumber"
+    xml_accessor :fax_number, :from => "FaxNumber"
+    xml_accessor :email_address, :from => "EmailAddress"
+    xml_accessor :websites, :from => "Website", :as => [ONIX::Website]
+    xml_accessor :supplier_role, :from => "SupplierRole", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :supply_to_country, :from => "SupplyToCountry"
+    xml_accessor :supply_to_territory, :from => "SupplyToTerritory"
+    xml_accessor :availability_status_code, :from => "AvailabilityStatusCode", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :product_availability, :from => "ProductAvailability", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :stock, :from => "Stock", :as => [ONIX::Stock]
+    xml_accessor :pack_quantity, :from => "PackQuantity", :as => Fixnum
+    xml_accessor :prices, :from => "Price", :as => [ONIX::Price]
+
+    def initialize
+      self.websites = []
+      self.stock = []
+      self.prices = []
+    end
+  end
+end

data/lib/onix/title.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+module ONIX
+  class Title
+    include ROXML 
+    include ONIX::Common
+
+    xml_name "Title"
+
+    xml_accessor :title_type, :from => "TitleType", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :title_text, :from => "TitleText"
+    xml_accessor :title_prefix, :from => "TitlePrefix"
+    xml_accessor :title_without_prefix, :from => "TitleWithoutPrefix"
+    xml_accessor :subtitle,   :from => "Subtitle"
+
+  end
+end

data/lib/onix/website.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+module ONIX
+  class Website
+    include ROXML
+    include ONIX::Common
+
+    xml_name "Website"
+
+    xml_accessor :website_role,        :from => "WebsiteRole", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
+    xml_accessor :website_description, :from => "WebsiteDescription"
+    xml_accessor :website_link,        :from => "WebsiteLink"
+  end
+end

data/lib/onix/writer.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+module ONIX
+  # The primary way to write a new ONIX file.
+  #
+  # Heres 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 = ONIX::Header.new
+  #     ONIX::Writer.open(output, header) do |writer|
+  #       writer << ONIX::Product.new
+  #       writer << ONIX::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 = ONIX::Header.new
+  #     ONIX::Writer.open(output, header) do |writer|
+  #       writer << ONIX::APAProduct.new
+  #       writer << ONIX::APAProduct.new
+  #     end
+  #   end
+  #
+  class Writer
+
+    DOCTYPE = "http://www.editeur.org/onix/2.1/03/reference/onix-international.dtd"
+
+    # Default constructor.
+    def initialize(output, header)
+      raise ArgumentError, 'msg must be an ONIX::Header object' unless header.kind_of?(ONIX::Header)
+      @output = output
+      @header = header
+      @finished = false
+
+      start_document
+    end
+
+    # deprecated
+    def start_document
+      puts "ONIX::StreamWriter#start_document is no longer required"
+    end
+
+    def << (product)
+      unless product.kind_of?(ONIX::Product) || product.kind_of?(ONIX::SimpleProduct)
+        raise ArgumentError, 'product must be an ONIX::Product or ONIX::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 end_document
+      @output.write("</ONIXMessage>\n")
+      @finished = true
+    end
+
+    def finished?
+      @finished
+    end
+
+    def self.open(output, header)
+      if block_given?
+        writer = self.new(output, header)
+        yield writer
+        writer.end_document
+      else
+        self.new(output, header)
+      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>\n")
+      @output.write(@header.to_xml.to_s)
+      @output.write("\n")
+    end
+
+  end
+end