milkfarm-onix 0.7.7 → 0.8.3

data/lib/onix/other_text.rb

@@ -3,7 +3,6 @@
 module ONIX
   class OtherText
     include ROXML
-    include ONIX::Common
 
     xml_name "OtherText"
 

data/lib/onix/price.rb

@@ -3,7 +3,6 @@
 module ONIX
   class Price
     include ROXML
-    include ONIX::Common
 
     xml_name "Price"
 

data/lib/onix/product.rb

@@ -3,16 +3,16 @@
 module ONIX
   class Product
     include ROXML
-    include ONIX::Common
 
     xml_name "Product"
-    
+
     xml_accessor :record_reference, :from => "RecordReference"
     xml_accessor :notification_type, :from => "NotificationType", :as => Fixnum, :to_xml => ONIX::Formatters.two_digit
     xml_accessor :product_identifiers, :from => "ProductIdentifier", :as => [ONIX::ProductIdentifier]
     xml_accessor :product_form, :from => "ProductForm"
     xml_accessor :product_form_detail, :from => "ProductFormDetail"
     xml_accessor :series, :from => "Series", :as => [ONIX::Series]
+    xml_accessor :sets, :from => "Set", :as => [ONIX::Set]
     xml_accessor :titles, :from => "Title", :as => [ONIX::Title]
     xml_accessor :websites, :from => "Website", :as => [ONIX::Website]
     xml_accessor :contributors, :from => "Contributor", :as => [ONIX::Contributor]
@@ -54,6 +54,7 @@ module ONIX
     def initialize
       self.product_identifiers = []
       self.series = []
+      self.sets = []
       self.titles = []
       self.contributors = []
       self.websites = []

data/lib/onix/product_identifier.rb

@@ -3,7 +3,6 @@
 module ONIX
   class ProductIdentifier
     include ROXML
-    include ONIX::Common
 
     xml_name "ProductIdentifier"
 

data/lib/onix/publisher.rb

@@ -3,7 +3,6 @@
 module ONIX
   class Publisher
     include ROXML
-    include ONIX::Common
 
     xml_name "Publisher"
 

data/lib/onix/reader.rb

@@ -53,31 +53,39 @@ module ONIX
   class Reader
     include Enumerable
 
-    attr_reader :header , :version, :xml_lang, :xml_version, :encoding
+    attr_reader :header, :release
 
     def initialize(input, product_klass = ::ONIX::Product)
       if input.kind_of?(String)
-        @reader = LibXML::XML::Reader.file(input)
+        @file   = File.open(input, "r")
+        @reader = Nokogiri::XML::Reader(@file) { |cfg| cfg.dtdload.noent }
       elsif input.kind_of?(IO)
-        @reader = LibXML::XML::Reader.io(input)
+        @reader = Nokogiri::XML::Reader(input) { |cfg| cfg.dtdload.noent }
       else
         raise ArgumentError, "Unable to read from file or IO stream"
       end
 
       @product_klass = product_klass
 
-      @header = read_next
+      @release = find_release
+      @header = find_header
 
-      @xml_lang    ||= @reader.xml_lang
+      @xml_lang    ||= @reader.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
+      @reader.each do |node|
+        if @reader.node_type == 1 && @reader.name == "Product"
+          str = @reader.outer_xml
+          if str.nil?
+            yield @product_klass.new
+          else
+            yield @product_klass.from_xml(str)
+          end
+        end
       end
     end
 
@@ -87,101 +95,36 @@ module ONIX
 
     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
+    def find_release
+      2.times do
+        @reader.read
+        if @reader.node_type == 1 && @reader.name == "ONIXMessage"
+          value = @reader.attributes["release"]
+          if value
+            return BigDecimal.new(value)
+          else
+            return nil
           end
+        elsif @reader.node_type == 14
+          return nil
         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
+    def find_header
+      100.times do
+        @reader.read
+        if @reader.node_type == 1 &&  @reader.name == "Header"
+          str = @reader.outer_xml
+          if str.nil?
+            return ONIX::Header.new
+          else
+            return ONIX::Header.from_xml(str)
+          end
+        end
       end
+      return nil
     end
   end
 end

data/lib/onix/sales_restriction.rb

@@ -3,7 +3,6 @@
 module ONIX
   class SalesRestriction
     include ROXML
-    include ONIX::Common
 
     xml_name "SalesRestriction"
 

data/lib/onix/sender_identifier.rb

@@ -3,7 +3,6 @@
 module ONIX
   class SenderIdentifier
     include ROXML
-    include ONIX::Common
 
     xml_name "SenderIdentifier"
 

data/lib/onix/series.rb

@@ -3,17 +3,16 @@
 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
@@ -23,7 +22,7 @@ module ONIX
     def proprietary_series_id=(id)
       series_identifier_set(1, id)
     end
-    
+
     # retrieve the issn
     def issn
       series_identifier(2).andand.id_value
@@ -33,7 +32,7 @@ module ONIX
     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 }
@@ -42,16 +41,17 @@ module ONIX
     # 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

@@ -3,7 +3,6 @@
 module ONIX
   class SeriesIdentifier
     include ROXML
-    include ONIX::Common
 
     xml_name "SeriesIdentifier"
 

data/lib/onix/set.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+module ONIX
+  class Set
+    include ROXML
+
+    xml_name "Set"
+
+    xml_accessor :product_identifiers, :from => "ProductIdentifier", :as => [ONIX::ProductIdentifier]
+    xml_accessor :title_of_set, :from => "TitleOfSet"
+    
+    def initialize
+      self.product_identifiers = []
+    end
+    
+    # retrieve the proprietary set ID
+    def proprietary_set_id
+      product_identifier(1).andand.id_value
+    end
+
+    # set a new proprietary set ID
+    def proprietary_set_id=(id)
+      product_identifier_set(1, id)
+    end
+    
+    # retrieve the 10-digit isbn
+    def isbn10
+      product_identifier(2).andand.id_value
+    end
+
+    # set a new 10-digit isbn
+    def isbn10=(id)
+      product_identifier_set(2, id)
+    end
+    
+    # retrieve the 13-digit isbn
+    def isbn
+      product_identifier(15).andand.id_value
+    end
+
+    # set a new 13-digit isbn
+    def isbn=(id)
+      product_identifier_set(15, id)
+    end
+    
+    # retrieve the lccn
+    def lccn
+      product_identifier(13).andand.id_value
+    end
+
+    # set a new lccn
+    def lccn=(id)
+      product_identifier_set(13, id)
+    end
+    
+    # retrieve the value of a particular ID
+    def product_identifier(type)
+      identifier = product_identifiers.find { |id| id.product_id_type == type }
+    end
+
+    # set the value of a particular ID
+    def product_identifier_set(type, value)
+      product_identifier_id = product_identifiers.find { |id| id.product_id_type == type }
+      
+      # create a new set identifier record if we need to
+      if product_identifier_id.nil?
+        product_identifier_id = ONIX::ProductIdentifier.new
+      end
+      
+      product_identifier_id.product_id_type = type
+      product_identifier_id.id_value = value
+      
+      product_identifiers << product_identifier_id
+    end
+  end
+end

data/lib/onix/sl_product.rb

@@ -2,18 +2,11 @@
 
 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 }
@@ -36,47 +29,41 @@ module ONIX
       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
+    # retrieve the value of a particular ID
+    def set(str)
+      product.sets.find { |id| id.title_of_set == str }
     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)
+    # set the value of a particular ID
+    def set=(value)
+      # process based on value type
+      if value.is_a?(Set)
+        str = value.title_of_set
+        set_id = value
+      else
+        str = value
+        set_id = ONIX::Set.new
+        set_id.title_of_set = value
+      end
+      # check if exists already
+      unless set(str)
+        product.sets << set_id
+      end
     end
     
-    # retrieve the value of a particular language
-    def language(type)
-      product.languages.find { |l| l.language_role == type }
+    # retrieve an array of all languages
+    def languages
+      product.languages.collect { |language| language.language_code}
     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
+    # set a new language to this product
+    # str should be the languages name code (US)
+    def add_language(str, role = "1", country = "US")
+      language = ::ONIX::Language.new
+      language.language_role = role
+      language.language_code = str
+      language.country_code = country
+      product.languages << language
     end
     
     # retrieve the dewey for this title
@@ -99,7 +86,7 @@ module ONIX
     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 }
@@ -126,6 +113,6 @@ module ONIX
       end
       a.audience_range_precisions = ["01"] if min.nil? || max.nil?
     end
-
+    
   end
 end