im_onix 1.1.1 → 1.3.0

data/lib/onix/subset.rb

@@ -1,13 +1,16 @@
+require 'forwardable'
+require 'cgi'
+
 module ONIX
   class ShortToRef
     def self.names
-      @shortnames ||= YAML.load(File.open(File.dirname(__FILE__) + "/../../data/shortnames.yml"))
+      @shortnames ||= YAML.load(File.open(File.dirname(__FILE__) + "/../../data/shortnames.yml")).freeze
     end
   end
 
   class RefToShort
     def self.names
-      @refnames ||= ShortToRef.names.invert
+      @refnames ||= ShortToRef.names.invert.freeze
     end
   end
 
@@ -22,8 +25,75 @@ module ONIX
     end
   end
 
+  # String only code-like class
+  class TextAttr
+    attr_accessor :code, :human
+
+    def self.from_code(code)
+      obj = self.new
+      obj.code = code
+      obj.human = code
+      obj
+    end
+  end
+
+  module Attributes
+    # @return [Hash<String,Code>]
+    attr_accessor :attributes
+
+    # @return [Hash<String,String>]
+    def serialized_attributes
+      if @attributes and @attributes.length > 0
+        attrs = {}
+        @attributes.each do |k, v|
+          attrs[k] = v.code if v
+        end
+        attrs
+      end
+    end
+
+    # @param [String] attr
+    # @return [Class]
+    def self.attribute_class(attr)
+      case attr
+      when "sourcename"
+        TextAttr
+      when "sourcetype"
+        RecordSourceType
+      when "collationkey"
+        TextAttr
+      when "dateformat"
+        DateFormat
+      when "datestamp"
+        DateStamp
+      when "language"
+        LanguageCode
+      when "textcase"
+        TextCase
+      when "textformat"
+        TextFormat
+      when "textscript"
+        ScriptCode
+      else
+        nil
+      end
+    end
+
+    def parse_attributes(attrs)
+      @attributes ||= {}
+      attrs.each do |k, v|
+        attr_klass = Attributes.attribute_class(k.to_s)
+        @attributes[k.to_s] = attr_klass ? attr_klass.from_code(v.to_s) : nil
+      end
+    end
+  end
+
   class Subset
+    include Attributes
+
     # instanciate Subset form Nokogiri::XML::Element
+    # @param [Nokogiri::XML::Element] n
+    # @return [Subset]
     def self.parse(n)
       o = self.new
       o.parse(n)
@@ -31,25 +101,25 @@ module ONIX
     end
 
     # parse Nokogiri::XML::Element
+    # @param [Nokogiri::XML::Element] n
+    # @return [void]
     def parse(n) end
 
+    # called when tag is not defined
+    # @param [String] tag
     def unsupported(tag)
-      #      raise SubsetUnsupported,tag.name
-      #      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{ShortToRef.names[tag.name]})"
+      # raise SubsetUnsupported, [self.class, tag.name]
+      # puts "WARN subset tag unsupported #{self.class}##{tag.name} (#{self.class.short_to_ref(tag.name)})"
     end
 
     def tag_match(v)
       TagNameMatcher.new(v)
     end
-
-    def self.tag_match(v)
-      TagNameMatcher.new(v)
-    end
-
   end
 
+  # for class DSL
   class ElementParser
-    attr_accessor :type, :name, :short
+    attr_accessor :type, :name, :short, :cardinality, :klass_name
 
     def self.inflectors
       [['ox', 'oxes'],
@@ -96,6 +166,8 @@ module ONIX
       @parse_lambda = options[:parse_lambda]
       @serialize_lambda = options[:serialize_lambda]
       @shortcut = options[:shortcut]
+      @cardinality = options[:cardinality]
+      @cardinality = nil if @cardinality == 0..n # no need to check if 0..n
 
       if options[:klass]
         @klass_name = options[:klass]
@@ -109,35 +181,20 @@ module ONIX
     end
 
     def parse_lambda(v)
-      if @parse_lambda
-        @parse_lambda.call(v)
-      else
-        v
-      end
+      @parse_lambda ? @parse_lambda.call(v) : v
     end
 
     def serialize_lambda(v)
-      if @serialize_lambda
-        @serialize_lambda.call(v)
-      else
-        v
-      end
+      @serialize_lambda ? @serialize_lambda.call(v) : v
     end
 
     def is_array?
       @array
     end
 
-    def _underscore_name
-      if @array and @pluralize
-        pluralize(underscore(@name))
-      else
-        underscore(@name)
-      end
-    end
-
+    # @return [String]
     def underscore_name
-      @underscore_name ||= _underscore_name
+      @underscore_name ||= (@array && @pluralize) ? pluralize(underscore(@name)) : underscore(@name)
     end
 
     def class_name
@@ -172,6 +229,9 @@ module ONIX
   end
 
   class SubsetArray < Array
+    # @param [Symbol] k
+    # @param [String] p
+    # @return [SubsetArray]
     def human_code_match(k, p)
       case p
       when Regexp
@@ -192,6 +252,9 @@ module ONIX
       end
     end
 
+    # @param [Symbol] k
+    # @param [String] p
+    # @return [SubsetArray]
     def code_match(k, p)
       case p
       when Regexp
@@ -205,111 +268,175 @@ module ONIX
     end
   end
 
-  class SubsetDSL < Subset
-    def self.scope(name, lambda)
-      @scopes ||= {}
-      @scopes[name] = lambda
+  class TextWithAttributes < SimpleDelegator
+    include Attributes
+
+    def parse(attrs)
+      parse_attributes(attrs)
     end
+  end
 
-    def self._ancestor_registered_scopes
-      els = self.registered_scopes
-      sup = self
-      while sup.respond_to?(:registered_scopes)
-        els.merge!(sup.registered_scopes) if sup.registered_scopes
-        sup = sup.superclass
+  # DSL
+  class SubsetDSL < Subset
+    class << self
+      # convert short name notation to reference
+      # @param [String] name
+      # @return [String]
+      def short_to_ref(name)
+        ShortToRef.names[name]
       end
-      els
-    end
 
-    def self.ancestor_registered_scopes
-      @ancestors_registered_scopes ||= _ancestor_registered_scopes
-    end
+      # convert reference name notation to short
+      # @param [String] name
+      # @return [String]
+      def ref_to_short(name)
+        RefToShort.names[name]
+      end
 
-    def self.registered_scopes
-      @scopes || {}
-    end
+      # infinity constant for cardinality
+      def n
+        Float::INFINITY
+      end
+
+      # define a scope
+      # @param [Symbol] name
+      # @param [Lambda] lambda
+      # @return [void]
+      def scope(name, lambda)
+        @scopes ||= {}
+        @scopes[name] = lambda
+      end
 
-    def self.element(name, type, options = {})
-      @elements ||= {}
-      @elements[name] = ElementParser.new(name, type, options)
-      short_name = self.ref_to_short(name)
-      if short_name
-        @elements[short_name] = @elements[name].dup
-        @elements[short_name].short = true
+      def registered_scopes
+        @scopes || {}
       end
-      attr_accessor @elements[name].to_sym
-      if @elements[name].shortcut
+
+      def register_scopes(scopes)
+        @scopes ||= {}
+        @scopes = scopes.merge(@scopes)
+      end
+
+      # define unique element
+      # @param [String] name
+      # @param [Symbol] type
+      # @param [Hash] options
+      # @return [void]
+      def element(name, type, options = {})
+        @elements ||= {}
+        @elements[name] = ElementParser.new(name, type, options)
+        short_name = self.ref_to_short(name)
+        if short_name
+          @elements[short_name] = @elements[name].dup
+          @elements[short_name].short = true
+        end
+
+        attr_accessor @elements[name].to_sym
+
+        alias_method "#{@elements[name].underscore_name}_with_attributes".to_sym, @elements[name].to_sym
+
         current_element = @elements[name]
-        define_method current_element.shortcut do |args = nil|
-          instance_variable_get(current_element.to_instance)
+        define_method current_element.to_sym do |args = nil|
+          val = instance_variable_get(current_element.to_instance)
+          if val.respond_to?(:__getobj__)
+            val.__getobj__
+          else
+            if val.is_a?(SubsetArray) and val.first and val.first.is_a?(TextWithAttributes)
+              val.map { |v| v.respond_to?(:__getobj__) ? v.__getobj__ : v }
+            else
+              val
+            end
+          end
         end
+
+        if @elements[name].shortcut
+          current_element = @elements[name]
+          alias_method "#{current_element.shortcut.to_s}_with_attributes".to_sym, "#{@elements[name].underscore_name}_with_attributes".to_sym
+          alias_method current_element.shortcut, @elements[name].to_sym
+        end
+
+        @elements[name]
       end
-    end
 
-    # shortcut for element :array=>true
-    def self.elements(name, type, options = {})
-      self.element(name, type, options.merge(:array => true))
-    end
+      # define multiple elements
+      # shortcut for element :array=>true
+      # @param [String] name
+      # @param [Symbol] type
+      # @param [Hash] options
+      # @return [void]
+      def elements(name, type, options = {})
+        self.element(name, type, options.merge(:array => true))
+      end
 
-    def self._ancestors_registered_elements
-      els = self.registered_elements
-      sup = self
-      while sup.respond_to?(:registered_elements)
-        els.merge!(sup.registered_elements) if sup.registered_elements
-        sup = sup.superclass
+      # registered elements for this subset
+      # @return [Hash]
+      def registered_elements
+        @elements || {}
       end
-      els
-    end
 
-    def self.ancestors_registered_elements
-      @ancestors_registered_elements ||= _ancestors_registered_elements
-    end
+      def register_elements(elements)
+        @elements ||= {}
+        @elements.merge!(elements)
+      end
 
-    def self.registered_elements
-      @elements || {}
+      def get_class(name)
+        ONIX.const_get(name) if ONIX.const_defined?(name)
+      end
+
+      def inherited(sublass)
+        sublass.register_scopes(self.registered_scopes)
+        sublass.register_elements(self.registered_elements)
+      end
     end
 
     def initialize
       # initialize plural as Array
-      self.class.ancestors_registered_elements.each do |k, e|
+      self.registered_elements.values.each do |e|
         if e.is_array?
-          # register a contextual SubsetArray object
-          subset_array = SubsetArray.new
-          subset_klass = self.class.get_class(e.class_name)
-          if subset_klass.respond_to? :registered_scopes
-            subset_klass.registered_scopes.each do |n, l|
-              unless subset_array.respond_to? n.to_s
-                subset_array.define_singleton_method(n.to_s) do
-                  instance_exec(&l)
-                end
-              end
-            end
-          end
-          instance_variable_set(e.to_instance, subset_array)
+          register_subset_array(e)
         end
       end
     end
 
-    def self.short_to_ref(name)
-      ShortToRef.names[name]
+    def register_subset_array(e)
+      # register a contextual SubsetArray object
+      subset_array = SubsetArray.new
+      subset_klass = self.get_class(e.class_name)
+      if subset_klass.respond_to?(:registered_scopes)
+        subset_klass.registered_scopes.each do |n, l|
+          unless subset_array.respond_to?(n.to_s)
+            subset_array.define_singleton_method(n.to_s) do
+              instance_exec(&l)
+            end
+          end
+        end
+      end
+      instance_variable_set(e.to_instance, subset_array)
     end
 
-    def self.ref_to_short(name)
-      RefToShort.names[name]
+    def registered_elements
+      self.class.registered_elements
     end
 
-    def self.get_class(name)
-      ONIX.const_get(name) if ONIX.const_defined? name
+    def get_class(name)
+      self.class.get_class(name)
     end
 
+    # @param [Nokogiri::XML::Element] n
+    # @return [void]
     def parse(n)
+      parse_attributes(n.attributes)
       n.elements.each do |t|
-        name = t.name
-        e = self.class.ancestors_registered_elements[name]
+        e = self.registered_elements[t.name]
         if e
+          primitive = true
           case e.type
           when :subset
-            val = self.class.get_class(e.class_name).parse(t)
+            klass = self.get_class(e.class_name)
+            unless klass
+              raise UnknownElement, e.class_name
+            end
+            val = klass.parse(t)
+            primitive = false
           when :text
             val = t.text
           when :integer
@@ -318,12 +445,41 @@ module ONIX
             val = t.text.to_f
           when :bool
             val = true
+          when :date
+            fmt = t["dateformat"] || "00"
+            begin
+              val = ONIX::Helper.to_date(fmt, t.text)
+            rescue
+              val = t.text
+            end
+          when :datestamp
+            tm = t.text
+            datestamp = DateStamp.new
+            datestamp.parse(tm)
+            val = datestamp
           when :ignore
             val = nil
           else
             val = t.text
           end
+
           if val
+            if primitive && t.attributes.length > 0
+              if t.attributes["textformat"] && t.attributes["textformat"].to_s == "05" # content is XHTML
+                xhtml = CGI.unescapeHTML(t.children.map { |x| x.to_s }.join.strip)
+                if Nokogiri::XML.parse(xhtml).root # check if val is really XHTML
+                  val = xhtml
+                else
+                  xhtml = CGI.unescapeHTML(val)
+                  if Nokogiri::XML.parse(xhtml).root
+                    val = xhtml
+                  end
+                end
+              end
+              val = TextWithAttributes.new(val)
+              val.parse(t.attributes)
+            end
+
             if e.is_array?
               instance_variable_get(e.to_instance).send(:push, val)
             else
@@ -335,10 +491,5 @@ module ONIX
         end
       end
     end
-
-    def unsupported(tag)
-      #      raise SubsetUnsupported,tag.name
-      #      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{self.class.short_to_ref(tag.name)})"
-    end
   end
 end

data/lib/onix/supplier_own_coding.rb

@@ -0,0 +1,7 @@
+module ONIX
+  class SupplierOwnCoding < SubsetDSL
+    element "SupplierCodeType", :subset, :cardinality => 1
+    element "SupplierCodeTypeName", :text, :cardinality => 0..1
+    element "SupplierCodeValue", :text, :cardinality => 1
+  end
+end

data/lib/onix/supply_contact.rb

@@ -0,0 +1,9 @@
+module ONIX
+  class SupplyContact < SubsetDSL
+    element "SupplyContactRole", :subset, :cardinality => 1
+    elements "SupplyContactIdentifier", :subset, :cardinality => 0..n
+    element "SupplyContactName", :text, :cardinality => 0..1
+    element "ContactName", :text, :cardinality => 0..1
+    element "EmailAddress", :text, :cardinality => 0..1
+  end
+end

data/lib/onix/supply_detail.rb

@@ -1,14 +1,37 @@
+require 'onix/supply_contact'
+require 'onix/supplier_own_coding'
+require 'onix/returns_conditions'
 require 'onix/price'
 
 module ONIX
   class SupplyDetail < SubsetDSL
-    elements "Supplier", :subset
-    element "ProductAvailability", :subset, :shortcut => :availability
-    elements "SupplyDate", :subset
-    elements "Price", :subset
-    element "UnpricedItemType", :subset
+    elements "Supplier", :subset, :cardinality => 1
+    elements "SupplyContact", :subset, :cardinality => 0..n
+    elements "SupplierOwnCoding", :subset, :cardinality => 0..n
+    elements "ReturnsConditions", :subset, :pluralize => false, :cardinality => 0..n
+    element "ProductAvailability", :subset, :shortcut => :availability, :cardinality => 1
+    elements "SupplyDate", :subset, :cardinality => 0..n
+    element "OrderTime", :integer, :cardinality => 0..1
+
+    # element "NewSupplier", :subset, :cardinality => 0..1
+    # elements "Stock", :subset, :cardinality => 0..n
+
+
+    element "PackQuantity", :integer, :cardinality => 0..1
+    element "PalletQuantity", :integer, :cardinality => 0..1
+    element "OrderQuantityMinimum", :integer, :cardinality => 0..1
+
+    # element "OrderQuantityMinimum", :integer, :cardinality => 0..1
+
+
+    element "OrderQuantityMultiple", :integer, :cardinality => 0..1
+    element "UnpricedItemType", :subset, :cardinality => 0..1
+    elements "Price", :subset, :cardinality => 0..n
+
+    # element "Reissue", :subset, :cardinality => 0..1
 
     # @!group Shortcuts
+    # @return [Array<Supplier>]
     def distributors
       @suppliers.select { |s| s.role.human =~ /Distributor/ }.uniq
     end

data/lib/onix/supporting_resource.rb

@@ -1,120 +1,15 @@
 require 'onix/date'
+require 'onix/resource_version'
+require 'onix/resource_feature'
 
 module ONIX
-  class ResourceVersionFeature < SubsetDSL
-    element "ResourceVersionFeatureType", :subset, :shortcut => :type
-    elements "FeatureNote", :text, :shortcut => :notes
-    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
-
-  class ResourceVersion < SubsetDSL
-    element "ResourceForm", :subset, :shortcut => :form
-    elements "ResourceVersionFeature", :subset, :shortcut => :features
-    elements "ResourceLink", :text, :shortcut => :links
-    elements "ContentDate", :subset
-
-    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
-
-  class ResourceFeature < SubsetDSL
-    element "ResourceFeatureType", :subset, :shortcut => :type
-    element "FeatureValue", :text, :shortcut => :value
-    elements "FeatureNotes", :text, :shortcut => :notes
-
-    scope :caption, lambda { human_code_match(:resource_feature_type, "Caption") }
-  end
-
   class SupportingResource < SubsetDSL
-    element "ResourceContentType", :subset, :shortcut => :type
-    element "ContentAudience", :subset, :shortcut => :target_audience
-    element "ResourceMode", :subset, :shortcut => :mode
-    elements "ResourceVersion", :subset, :shortcut => :versions
-    elements "ResourceFeature", :subset, :shortcut => :features
+    element "ResourceContentType", :subset, :shortcut => :type, :cardinality => 1
+    element "ContentAudience", :subset, :shortcut => :target_audience, :cardinality => 1..n
+    element "Territory", :subset, :cardinality => 0..1
+    element "ResourceMode", :subset, :shortcut => :mode, :cardinality => 1
+    elements "ResourceFeature", :subset, :shortcut => :features, :cardinality => 0..n
+    elements "ResourceVersion", :subset, :shortcut => :versions, :cardinality => 1..n
 
     scope :front_cover, lambda { human_code_match(:resource_content_type, "FrontCover") }
     scope :sample_content, lambda { human_code_match(:resource_content_type, "SampleContent") }
@@ -122,10 +17,12 @@ module ONIX
     scope :image, lambda { human_code_match(:resource_mode, "Image") }
     scope :text, lambda { human_code_match(:resource_mode, "Text") }
 
+    # @return [ResourceFeature]
     def caption_feature
       self.features.caption.first
     end
 
+    # @return [String]
     def caption
       if self.caption_feature
         self.caption_feature.value