im_onix 1.1.1 → 1.2.2

data/lib/onix/resource_feature.rb

@@ -0,0 +1,9 @@
+module ONIX
+  class ResourceFeature < SubsetDSL
+    element "ResourceFeatureType", :subset, :shortcut => :type, :cardinality => 1
+    element "FeatureValue", :text, :shortcut => :value, :cardinality => 0..1
+    elements "FeatureNote", :text, :shortcut => :notes, :cardinality => 0..n
+
+    scope :caption, lambda { human_code_match(:resource_feature_type, "Caption") }
+  end
+end

data/lib/onix/resource_version.rb

@@ -0,0 +1,82 @@
+require 'onix/resource_version_feature'
+
+module ONIX
+  class ResourceVersion < SubsetDSL
+    element "ResourceForm", :subset, :shortcut => :form, :cardinality => 1
+    elements "ResourceVersionFeature", :subset, :shortcut => :features, :cardinality => 0..n
+    elements "ResourceLink", :text, :shortcut => :links, :cardinality => 1..n
+    elements "ContentDate", :subset, :cardinality => 0..n
+
+    def filename
+      if @resource_form.human == "DownloadableFile"
+        resource_links.first
+      end
+    end
+
+    def file_format_feature
+      @resource_version_features.select { |f| f.type.human == "FileFormat" }.first
+    end
+
+    def file_format
+      if ["DownloadableFile", "LinkableResource"].include?(@resource_form.human)
+        if file_format_feature
+          file_format_feature.value.human
+        end
+      end
+    end
+
+    def file_mimetype
+      if ["DownloadableFile", "LinkableResource"].include?(@resource_form.human)
+        if file_format_feature
+          file_format_feature.value.mimetype
+        end
+      end
+    end
+
+    def image_width_feature
+      @resource_version_features.image_pixels_width.first
+    end
+
+    def image_height_feature
+      @resource_version_features.image_pixels_height.first
+    end
+
+    def md5_hash_feature
+      @resource_version_features.md5_hash.first
+    end
+
+    def image_width
+      if self.image_width_feature
+        self.image_width_feature.value.to_i
+      end
+    end
+
+    def image_height
+      if self.image_height_feature
+        self.image_height_feature.value.to_i
+      end
+    end
+
+    def md5_hash
+      if self.md5_hash_feature
+        self.md5_hash_feature.value
+      end
+    end
+
+    def last_updated_content_date
+      @content_dates.last_updated.first
+    end
+
+    def last_updated
+      if self.last_updated_content_date
+        self.last_updated_content_date.date
+      end
+    end
+
+    def last_updated_utc
+      if self.last_updated_content_date and self.last_updated_content_date.date
+        self.last_updated_content_date.date.to_time.utc.strftime('%Y%m%dT%H%M%S%z')
+      end
+    end
+  end
+end

data/lib/onix/resource_version_feature.rb

@@ -0,0 +1,22 @@
+module ONIX
+  class ResourceVersionFeature < SubsetDSL
+    element "ResourceVersionFeatureType", :subset, :shortcut => :type, :cardinality => 1
+    elements "FeatureNote", :text, :shortcut => :notes, :cardinality => 0..n
+    element "FeatureValue", :text, {
+      :shortcut => :value,
+      :serialize_lambda => lambda { |v| v.class == SupportingResourceFileFormat ? v.code : v }
+    }
+
+    scope :image_pixels_width, lambda { human_code_match(:resource_version_feature_type, "ImageWidthInPixels") }
+    scope :image_pixels_height, lambda { human_code_match(:resource_version_feature_type, "ImageHeightInPixels") }
+    scope :md5_hash, lambda { human_code_match(:resource_version_feature_type, "Md5HashValue") }
+
+    def parse(n)
+      super
+
+      if @resource_version_feature_type.human == "FileFormat"
+        @feature_value = SupportingResourceFileFormat.from_code(@feature_value)
+      end
+    end
+  end
+end

data/lib/onix/returns_conditions.rb

@@ -0,0 +1,8 @@
+module ONIX
+  class ReturnsConditions < SubsetDSL
+    element "ReturnsCodeType", :subset, :cardinality => 1
+    element "ReturnsCodeTypeName", :text, :cardinality => 0..1
+    element "ReturnsCode", :subset, :cardinality => 1
+    elements "ReturnsNote", :text, :cardinality => 0..n
+  end
+end

data/lib/onix/review_rating.rb

@@ -0,0 +1,7 @@
+module ONIX
+  class ReviewRating < SubsetDSL
+    element "Rating", :text, :cardinality => 1
+    element "RatingLimit", :integer, :cardinality => 0..1
+    elements "RatingUnits", :text, :cardinality => 0..n
+  end
+end

data/lib/onix/sales_outlet.rb

@@ -1,6 +1,14 @@
 module ONIX
   class SalesOutlet < SubsetDSL
-    element "SalesOutletIdentifier", :subset, :shortcut => :identifier
-    element "SalesOutletName", :text, :shortcut => :name
+    elements "SalesOutletIdentifier", :subset, :shortcut => :identifiers, :cardinality => 0..n
+    element "SalesOutletName", :text, :shortcut => :name, :cardinality => 0..1
+
+    def sales_outlet_identifier
+      self.sales_outlet_identifiers.first
+    end
+
+    def identifier
+      self.identifiers.first
+    end
   end
 end

data/lib/onix/sales_restriction.rb

@@ -2,23 +2,13 @@ require 'onix/sales_outlet'
 module ONIX
   class SalesRestriction < SubsetDSL
     element "SalesRestrictionType", :subset, :shortcut => :type
-    elements "SalesOutlet", :subset
-    element "SalesRestrictionNote", :text, :shortcut => :note
+    elements "SalesOutlet", :subset, :cardinality => 0..n
+    elements "SalesRestrictionNote", :text, :shortcut => :notes
+    element "StartDate", :date, :cardinality => 0..1
+    element "EndDate", :date, :cardinality => 0..1
 
-    attr_accessor :start_date, :end_date
-
-    def parse(n)
-      super
-      n.elements.each do |t|
-        case t
-        when tag_match("StartDate")
-          fmt = t["dateformat"] || "00"
-          @start_date = ONIX::Helper.to_date(fmt, t.text)
-        when tag_match("EndDate")
-          fmt = t["dateformat"] || "00"
-          @end_date = ONIX::Helper.to_date(fmt, t.text)
-        end
-      end
+    def note
+      self.notes.first
     end
   end
 end

data/lib/onix/sales_rights.rb

@@ -1,8 +1,11 @@
 require 'onix/sales_restriction'
+
 module ONIX
   class SalesRights < SubsetDSL
-    element "SalesRightsType", :subset, :shortcut => :type
-    element "Territory", :subset
-    elements "SalesRestriction", :subset
+    element "SalesRightsType", :subset, :shortcut => :type, :cardinality => 1
+    element "Territory", :subset, :cardinality => 1
+    elements "SalesRestriction", :subset, :cardinality => 0..n
+    elements "ProductIdentifier", :subset, :cardinality => 0..n
+    element "PublisherName", :text, :cardinality => 0..1
   end
 end

data/lib/onix/sender.rb

@@ -4,9 +4,9 @@ module ONIX
   class Sender < SubsetDSL
     include GlnMethods
 
-    elements "SenderIdentifier", :subset, :shortcut => :identifiers
-    element "SenderName", :text, :shortcut => :name
-    element "ContactName", :text
-    element "EmailAddress", :text
+    elements "SenderIdentifier", :subset, :shortcut => :identifiers, :cardinality => 0..n
+    element "SenderName", :text, :shortcut => :name, :cardinality => 0..1
+    element "ContactName", :text, :cardinality => 0..1
+    element "EmailAddress", :text, :cardinality => 0..1
   end
 end

data/lib/onix/serializer.rb

@@ -1,156 +1,200 @@
 module ONIX
+  class Root < SubsetDSL
+    element "ONIXMessage", :subset
+    elements "Product", :subset
+  end
+
   module Serializer
     class Traverser
 
-      def self.serialize_subset(mod, xml, subset, parent_tag = nil, level = 0)
-        if subset.class.included_modules.include?(DateHelper)
-          mod.const_get("Date").serialize(xml, subset, parent_tag, level)
+      def self.serialize(mod, xml, subset, tag = nil)
+        ONIX::Serializer::Traverser.serialize_subset(mod, xml, subset, tag)
+      end
+
+      def self.serialize_subset(mod, data, subset, parent_tag = nil, level = 0)
+        if subset.is_a?(ONIX::Root)
+          ONIX::Serializer::Traverser.recursive_serialize(mod, data, subset, parent_tag, level)
         else
-          if subset.class.included_modules.include?(CodeHelper)
-            mod.const_get("Code").serialize(xml, subset, parent_tag, level)
+          if subset.is_a?(ONIX::ONIXMessage)
+            mod.const_get("Root").serialize(data, subset, "ONIXMessage", level)
           else
-            if subset.class.included_modules.include?(EntityHelper)
-              mod.const_get("Entity").serialize(xml, subset, parent_tag, level)
+            if subset.class.included_modules.include?(DateHelper)
+              mod.const_get("Date").serialize(data, subset, parent_tag, level)
             else
-              mod.const_get("Subset").serialize(xml, parent_tag, subset, level)
+              if subset.class.included_modules.include?(CodeHelper)
+                mod.const_get("Code").serialize(data, subset, parent_tag, level)
+              else
+                mod.const_get("Subset").serialize(data, subset, parent_tag, level)
+              end
             end
           end
         end
       end
 
-      def self.recursive_serialize(mod, xml, subset, parent_tag = nil, level = 0)
+      def self.any_serialize(type, mod, data, val, tag, level)
+        case type
+        when :subset
+          self.serialize_subset(mod, data, val, tag, level)
+        when :datestamp
+          mod.const_get("Primitive").serialize(data, val.code, tag, level)
+        when :text, :integer, :float
+          mod.const_get("Primitive").serialize(data, val, tag, level)
+        when :bool
+          mod.const_get("Primitive").serialize(data, nil, tag, level) if val
+        when :ignore
+        else
+        end
+      end
+
+      def self.recursive_serialize(mod, data, subset, parent_tag = nil, level = 0)
         if subset.class.respond_to?(:ancestors_registered_elements)
-          subset.class.ancestors_registered_elements.each do |n, e|
-            unless e.short
-              v = subset.instance_variable_get(e.to_instance)
-              if v
-                if e.is_array?
-                  v.each do |vv|
-                    case e.type
-                      when :subset
-                        self.serialize_subset(mod, xml, vv, n, level)
-                      when :text, :integer, :float, :bool
-                        mod.const_get("Primitive").serialize(xml, n, vv, level)
-                      when :ignore
-                      else
-                    end
-                  end
-                else
-                  case e.type
-                    when :subset
-                      self.serialize_subset(mod, xml, v, n, level)
-                    when :text, :integer, :float, :bool
-                      mod.const_get("Primitive").serialize(xml, n, e.serialize_lambda(v), level)
-                    when :ignore
-                    else
-                  end
+          subset.class.ancestors_registered_elements.each do |tag, element|
+            next if element.short
+            val = subset.instance_variable_get(element.to_instance)
+            if val
+              if element.is_array?
+                val.each do |subval|
+                  self.any_serialize(element.type, mod, data, subval, tag, level)
                 end
+              else
+                self.any_serialize(element.type, mod, data, element.serialize_lambda(val), tag, level)
               end
             end
           end
         end
-
       end
     end
 
     module Default
-      class Subset
-        def self.serialize(xml, tag, subset, level = 0)
-          xml.send(tag, nil) {
-            ONIX::Serializer::Traverser.recursive_serialize(Default, xml, subset, tag, level+1)
+      def self.serialize(xml, subset, tag = nil)
+        ONIX::Serializer::Traverser.serialize(Default, xml, subset, tag)
+      end
+
+      class Root
+        def self.serialize(xml, subset, tag, level = 0)
+          root_options = subset.version && subset.version >= 300 ? { :xmlns => "http://ns.editeur.org/onix/3.0/reference", :release => subset.release } : {}
+          xml.send(tag, root_options) {
+            ONIX::Serializer::Traverser.recursive_serialize(Default, xml, subset, tag, level + 1)
           }
         end
       end
 
+      class Subset
+        def self.serialize(xml, subset, tag, level = 0)
+          if tag
+            xml.send(tag, subset.serialized_attributes) {
+              ONIX::Serializer::Traverser.recursive_serialize(Default, xml, subset, tag, level + 1)
+            }
+          end
+        end
+      end
+
       class Primitive
-        def self.serialize(xml, tag, data, level = 0)
-          unless data.respond_to?(:empty?) ? !!data.empty? : !data # rails blank?
-            xml.send(tag, data)
+        def self.serialize(xml, val, tag, level = 0)
+          if val.is_a?(ONIX::TextWithAttributes)
+            if val.serialized_attributes["textformat"] == "05" # content is XHTML
+              xml.send(tag, val.serialized_attributes) do
+                xml.__send__ :insert, val.to_s
+              end
+            else
+              xml.send(tag, val.serialized_attributes, val)
+            end
+          else
+            xml.send(tag, val)
           end
         end
       end
 
       class Date
         def self.serialize(xml, date, parent_tag = nil, level = 0)
+          deprecated_date_format = date.deprecated_date_format
+          date_format = date.date_format || DateFormat.from_code("00")
+          code_format = date.format_from_code(date_format.code)
+
           xml.send(parent_tag, nil) {
-            ONIX::Serializer::Traverser.recursive_serialize(Default, xml, date, parent_tag, level+1)
-            xml.DateFormat(date.date_format.code)
-            code_format=date.format_from_code(date.date_format.code)
-            xml.Date(date.date.strftime(code_format))
+            date.class.ancestors_registered_elements.each do |tag, element|
+              next if element.short
+              val = date.instance_variable_get(element.to_instance)
+              if val
+                case tag
+                when "DateFormat"
+                  if deprecated_date_format
+                    xml.DateFormat(date_format.code)
+                  end
+                when "Date"
+                  if deprecated_date_format
+                    xml.Date(date.date.strftime(code_format))
+                  else
+                    attrs = date.date_format ? { :dateformat => date_format.code } : {}
+                    xml.Date(date.date.strftime(code_format), attrs)
+                  end
+                else
+                  ONIX::Serializer::Traverser.any_serialize(element.type, Default, xml, element.serialize_lambda(val), tag, level)
+                end
+              end
+            end
           }
-
         end
       end
 
       class Code
         def self.serialize(xml, code, parent_tag = nil, level = 0)
-          xml.send(parent_tag, nil) {
+          xml.send(parent_tag, code.serialized_attributes) {
             xml.text(code.code)
           }
         end
       end
+    end
 
-      class Entity
-        def self.serialize(xml, entity, parent_tag = nil, level = 0)
-          xml.send(parent_tag, nil) {
-            if entity.role
-              Code.serialize(xml, entity.role, entity.class.role_tag, level+1)
-            end
-            entity.identifiers.each do |identifier|
-              Subset.serialize(xml, entity.class.identifier_tag, identifier, level+1)
-            end
-            if entity.name
-              xml.send(entity.class.name_tag, entity.name)
-            end
-            ONIX::Serializer::Traverser.recursive_serialize(Default, xml, entity, parent_tag, level+1)
-          }
+    module Dump
+      def self.serialize(io, subset, tag = nil)
+        ONIX::Serializer::Traverser.serialize(Dump, io, subset, tag)
+      end
+
+      class Root
+        def self.serialize(io, subset, tag, level = 0)
+          io.write " " * level
+          io.write "#{tag}(ROOT):\n"
+          ONIX::Serializer::Traverser.recursive_serialize(Dump, io, subset, tag, level + 1)
         end
       end
-    end
 
-    module Dump
       class Subset
-        def self.serialize(io, tag, subset, level = 0)
-          io.write " "*level
-          io.write "#{tag}:\n"
-          ONIX::Serializer::Traverser.recursive_serialize(Dump, io, subset, tag, level+1)
+        def self.serialize(io, subset, tag, level = 0)
+          io.write " " * level
+          if subset.attributes.length > 0
+            io.write "#{tag}[#{subset.attributes.to_a.map { |k, v| "#{k}: #{v.code}(#{v.human})" }.join(", ")}]\n"
+          else
+            io.write "#{tag}:\n"
+          end
+          ONIX::Serializer::Traverser.recursive_serialize(Dump, io, subset, tag, level + 1)
         end
       end
 
       class Primitive
-        def self.serialize(io, tag, data, level = 0)
-          unless data.respond_to?(:empty?) ? !!data.empty? : !data # rails blank?
-            io.write " "*level
-            io.write "#{tag} : #{data}\n"
+        def self.serialize(io, val, tag, level = 0)
+          io.write " " * level
+          if val.is_a?(ONIX::TextWithAttributes)
+            io.write "#{tag}[#{val.attributes.to_a.map { |k, v| "#{k}: #{v.code}(#{v.human})" }.join(", ")}]: #{val.to_s}\n"
+          else
+            io.write "#{tag}: #{val}\n"
           end
         end
       end
 
       class Date
         def self.serialize(io, date, parent_tag = nil, level = 0)
-          io.write " "*level
+          io.write " " * level
           io.write "#{parent_tag}: #{date.date}\n"
         end
       end
 
       class Code
         def self.serialize(io, code, parent_tag = nil, level = 0)
-          io.write " "*level
+          io.write " " * level
           io.write "#{parent_tag}: #{code.human}(#{code.code})\n"
         end
       end
-
-      class Entity
-        def self.serialize(io, entity, parent_tag = nil, level = 0)
-          io.write " "*level
-          io.write "#{parent_tag}: #{entity.name}\n"
-          if entity.role
-            io.write " "*(level+1)
-            io.write "Role: #{entity.role.human}(#{entity.role.code})\n"
-          end
-        end
-      end
     end
-
   end
-end
+end