im_onix 1.0.2 → 1.1.1

data/lib/onix/subject.rb

@@ -1,35 +1,14 @@
 module ONIX
   class Subject < SubsetDSL
     element "MainSubject", :bool
-    element "SubjectSchemeIdentifier", :subset
-    element "SubjectSchemeName", :text
-    element "SubjectSchemeVersion", :text
-    element "SubjectCode", :text
-    element "SubjectHeadingText", :text
-
-    scope :bisac, lambda{ human_code_match(:subject_scheme_identifier, "BisacSubjectHeading") }
-    scope :clil, lambda{ human_code_match(:subject_scheme_identifier, "Clil") }
-    scope :keyword, lambda{ human_code_match(:subject_scheme_identifier, "Keywords") }
-
-    # shortcuts
-    def code
-      @subject_code
-    end
-
-    def heading_text
-      @subject_heading_text
-    end
-
-    def scheme_identifier
-      @subject_scheme_identifier
-    end
-
-    def scheme_name
-      @subject_scheme_name
-    end
-
-    def scheme_version
-      @subject_scheme_version
-    end
+    element "SubjectSchemeIdentifier", :subset, :shortcut => :scheme_identifier
+    element "SubjectSchemeName", :text, :shortcut => :scheme_name
+    element "SubjectSchemeVersion", :text, :shortcut => :scheme_version
+    element "SubjectCode", :text, :shortcut => :code
+    element "SubjectHeadingText", :text, :shortcut => :heading_text
+
+    scope :bisac, lambda { human_code_match(:subject_scheme_identifier, "BisacSubjectHeading") }
+    scope :clil, lambda { human_code_match(:subject_scheme_identifier, "Clil") }
+    scope :keyword, lambda { human_code_match(:subject_scheme_identifier, "Keywords") }
   end
 end

data/lib/onix/subset.rb

@@ -1,20 +1,20 @@
 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"))
     end
   end
 
   class RefToShort
     def self.names
-      @refnames||=ShortToRef.names.invert
+      @refnames ||= ShortToRef.names.invert
     end
   end
 
   TagNameMatcher = Struct.new(:tag_name) do
     def ===(target)
       if target.element?
-        name=target.name
+        name = target.name
         name.casecmp(tag_name) == 0 or ShortToRef.names[name] == tag_name
       else
         false
@@ -25,18 +25,17 @@ module ONIX
   class Subset
     # instanciate Subset form Nokogiri::XML::Element
     def self.parse(n)
-      o=self.new
+      o = self.new
       o.parse(n)
       o
     end
 
     # parse Nokogiri::XML::Element
-    def parse(n)
-    end
+    def parse(n) end
 
     def unsupported(tag)
-#      raise SubsetUnsupported,tag.name
-#      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{ShortToRef.names[tag.name]})"
+      #      raise SubsetUnsupported,tag.name
+      #      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{ShortToRef.names[tag.name]})"
     end
 
     def tag_match(v)
@@ -79,31 +78,36 @@ module ONIX
        ['ouse', 'ouses']]
     end
 
-    def initialize(name, type, options={})
-      @name=name
-      @type=type
-      @pluralize=true
+    def initialize(name, type, options = {})
+      @name = name
+      @type = type
+      @pluralize = true
       @short = false
-      @array=false
+      @array = false
       @parse_lambda = nil
       @serialize_lambda = nil
       if options[:array]
-        @array=true
+        @array = true
       end
-      if options[:pluralize]==false
-        @pluralize=false
+      if options[:pluralize] == false
+        @pluralize = false
       end
 
-      @parse_lambda=options[:parse_lambda]
-      @serialize_lambda=options[:serialize_lambda]
+      @parse_lambda = options[:parse_lambda]
+      @serialize_lambda = options[:serialize_lambda]
+      @shortcut = options[:shortcut]
 
       if options[:klass]
-        @klass_name=options[:klass]
+        @klass_name = options[:klass]
       else
-        @klass_name=name
+        @klass_name = name
       end
     end
 
+    def shortcut
+      @shortcut
+    end
+
     def parse_lambda(v)
       if @parse_lambda
         @parse_lambda.call(v)
@@ -133,7 +137,7 @@ module ONIX
     end
 
     def underscore_name
-      @underscore_name||=_underscore_name
+      @underscore_name ||= _underscore_name
     end
 
     def class_name
@@ -141,14 +145,15 @@ module ONIX
     end
 
     def to_sym
-      @sym||=self.underscore_name.to_sym
+      @sym ||= self.underscore_name.to_sym
     end
 
     def to_instance
-      @instance||="@"+self.underscore_name
+      @instance ||= "@" + self.underscore_name
     end
 
     private
+
     def pluralize(str)
       rex = /(#{self.class.inflectors.map { |si, pl| si }.join('|')})$/i
       hash = Hash[*self.class.inflectors.flatten]
@@ -169,33 +174,33 @@ module ONIX
   class SubsetArray < Array
     def human_code_match(k, p)
       case p
-        when Regexp
-          self.class.new(self.select { |v|
-            code=v.instance_variable_get("@"+k.to_s)
-            code and code.human =~ p
-          })
-        when Array
-          self.class.new(self.select { |v|
-            code=v.instance_variable_get("@"+k.to_s)
-            code and p.include?(code.human)
-          })
-        else
-          self.class.new(self.select { |v|
-            code=v.instance_variable_get("@"+k.to_s)
-            code and code.human == p
-          })
+      when Regexp
+        self.class.new(self.select { |v|
+          code = v.instance_variable_get("@" + k.to_s)
+          code and code.human =~ p
+        })
+      when Array
+        self.class.new(self.select { |v|
+          code = v.instance_variable_get("@" + k.to_s)
+          code and p.include?(code.human)
+        })
+      else
+        self.class.new(self.select { |v|
+          code = v.instance_variable_get("@" + k.to_s)
+          code and code.human == p
+        })
       end
     end
 
     def code_match(k, p)
       case p
-        when Regexp
-          self.class.new(self.select { |v|
-            code=v.instance_variable_get("@"+k.to_s)
-            code.code =~ p
-          })
-        else
-          self.class.new(self.select { |v| v.instance_variable_get("@"+k.to_s).code == p })
+      when Regexp
+        self.class.new(self.select { |v|
+          code = v.instance_variable_get("@" + k.to_s)
+          code.code =~ p
+        })
+      else
+        self.class.new(self.select { |v| v.instance_variable_get("@" + k.to_s).code == p })
       end
     end
   end
@@ -207,55 +212,61 @@ module ONIX
     end
 
     def self._ancestor_registered_scopes
-      els=self.registered_scopes
-      sup=self
+      els = self.registered_scopes
+      sup = self
       while sup.respond_to?(:registered_scopes)
         els.merge!(sup.registered_scopes) if sup.registered_scopes
-        sup=sup.superclass
+        sup = sup.superclass
       end
       els
     end
 
     def self.ancestor_registered_scopes
-      @ancestors_registered_scopes||=_ancestor_registered_scopes
+      @ancestors_registered_scopes ||= _ancestor_registered_scopes
     end
 
     def self.registered_scopes
-      @scopes||{}
+      @scopes || {}
     end
 
-    def self.element(name, type, options={})
+    def self.element(name, type, options = {})
       @elements ||= {}
-      @elements[name]=ElementParser.new(name, type, options)
-      short_name=self.ref_to_short(name)
+      @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] = @elements[name].dup
         @elements[short_name].short = true
       end
       attr_accessor @elements[name].to_sym
+      if @elements[name].shortcut
+        current_element = @elements[name]
+        define_method current_element.shortcut do |args = nil|
+          instance_variable_get(current_element.to_instance)
+        end
+      end
     end
 
     # shortcut for element :array=>true
-    def self.elements(name, type, options={})
+    def self.elements(name, type, options = {})
       self.element(name, type, options.merge(:array => true))
     end
 
     def self._ancestors_registered_elements
-      els=self.registered_elements
-      sup=self
+      els = self.registered_elements
+      sup = self
       while sup.respond_to?(:registered_elements)
         els.merge!(sup.registered_elements) if sup.registered_elements
-        sup=sup.superclass
+        sup = sup.superclass
       end
       els
     end
 
     def self.ancestors_registered_elements
-      @ancestors_registered_elements||=_ancestors_registered_elements
+      @ancestors_registered_elements ||= _ancestors_registered_elements
     end
 
     def self.registered_elements
-      @elements||{}
+      @elements || {}
     end
 
     def initialize
@@ -294,23 +305,23 @@ module ONIX
     def parse(n)
       n.elements.each do |t|
         name = t.name
-        e=self.class.ancestors_registered_elements[name]
+        e = self.class.ancestors_registered_elements[name]
         if e
           case e.type
-            when :subset
-              val=self.class.get_class(e.class_name).parse(t)
-            when :text
-              val=t.text
-            when :integer
-              val=t.text.to_i
-            when :float
-              val=t.text.to_f
-            when :bool
-              val=true
-            when :ignore
-              val=nil
-            else
-              val=t.text
+          when :subset
+            val = self.class.get_class(e.class_name).parse(t)
+          when :text
+            val = t.text
+          when :integer
+            val = t.text.to_i
+          when :float
+            val = t.text.to_f
+          when :bool
+            val = true
+          when :ignore
+            val = nil
+          else
+            val = t.text
           end
           if val
             if e.is_array?
@@ -326,9 +337,8 @@ module ONIX
     end
 
     def unsupported(tag)
-#      raise SubsetUnsupported,tag.name
-#      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{self.class.short_to_ref(tag.name)})"
+      #      raise SubsetUnsupported,tag.name
+      #      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{self.class.short_to_ref(tag.name)})"
     end
-
   end
 end

data/lib/onix/supply_detail.rb

@@ -0,0 +1,42 @@
+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
+
+    # @!group Shortcuts
+    def distributors
+      @suppliers.select { |s| s.role.human =~ /Distributor/ }.uniq
+    end
+
+    # @!endgroup
+
+    # @!group High level
+    # is supply available ?
+    # @return [Boolean]
+    def available?
+      ["Available", "NotYetAvailable", "InStock", "ToOrder", "Pod"].include?(@product_availability.human)
+    end
+
+    # does supply can be sold separately ?
+    # @return [Boolean]
+    def sold_separately?
+      @product_availability.human != "NotSoldSeparately"
+    end
+
+    # supply availability date
+    # @return [Date]
+    def availability_date
+      av = @supply_dates.availability.first
+      if av
+        av.date
+      end
+    end
+
+    # @!endgroup
+  end
+end

data/lib/onix/supporting_resource.rb

@@ -2,62 +2,40 @@ require 'onix/date'
 
 module ONIX
   class ResourceVersionFeature < SubsetDSL
-    element "ResourceVersionFeatureType", :subset
-    elements "FeatureNote", :text
-    element "FeatureValue", :text, :serialize_lambda => lambda {|v| v.class == SupportingResourceFileFormat ? v.code : v}
+    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 type
-      @resource_version_feature_type
-    end
-
-    def value
-      @feature_value
-    end
-
-    def notes
-      @feature_notes
-    end
+    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)
+      if @resource_version_feature_type.human == "FileFormat"
+        @feature_value = SupportingResourceFileFormat.from_code(@feature_value)
       end
     end
   end
 
   class ResourceVersion < SubsetDSL
-    element "ResourceForm", :subset
-    elements "ResourceVersionFeature", :subset
-    elements "ResourceLink", :text
+    element "ResourceForm", :subset, :shortcut => :form
+    elements "ResourceVersionFeature", :subset, :shortcut => :features
+    elements "ResourceLink", :text, :shortcut => :links
     elements "ContentDate", :subset
 
-    # shortcuts
-    def form
-      @resource_form
-    end
-
-    def links
-      @resource_links
-    end
-
-    def features
-      @resource_version_features
-    end
-
     def filename
-      if @resource_form.human=="DownloadableFile"
+      if @resource_form.human == "DownloadableFile"
         @resource_links.first
       end
     end
 
     def file_format_feature
-      @resource_version_features.select { |f| f.type.human=="FileFormat" }.first
+      @resource_version_features.select { |f| f.type.human == "FileFormat" }.first
     end
 
     def file_format
@@ -124,55 +102,25 @@ module ONIX
   end
 
   class ResourceFeature < SubsetDSL
-    element "ResourceFeatureType", :subset
-    element "FeatureValue", :text
-    elements "FeatureNotes", :text
-
-    scope :caption, lambda { human_code_match(:resource_feature_type, "Caption")}
-
-    # shortcuts
-    def type
-      @resource_feature_type
-    end
+    element "ResourceFeatureType", :subset, :shortcut => :type
+    element "FeatureValue", :text, :shortcut => :value
+    elements "FeatureNotes", :text, :shortcut => :notes
 
-    def value
-      @feature_value
-    end
-
-    def notes
-      @feature_notes
-    end
+    scope :caption, lambda { human_code_match(:resource_feature_type, "Caption") }
   end
 
   class SupportingResource < SubsetDSL
-    element "ResourceContentType", :subset
-    element "ContentAudience", :subset
-    element "ResourceMode", :subset
-    elements "ResourceVersion", :subset
-    elements "ResourceFeature", :subset
-
-    scope :front_cover, lambda { human_code_match(:resource_content_type, "FrontCover")}
-    scope :sample_content, lambda { human_code_match(:resource_content_type, "SampleContent")}
-
-    scope :image, lambda {human_code_match(:resource_mode, "Image")}
-    scope :text, lambda {human_code_match(:resource_mode, "Text")}
-
-    # shortcuts
-    def type
-      @resource_content_type
-    end
+    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
 
-    def mode
-      @resource_mode
-    end
-
-    def versions
-      @resource_versions
-    end
+    scope :front_cover, lambda { human_code_match(:resource_content_type, "FrontCover") }
+    scope :sample_content, lambda { human_code_match(:resource_content_type, "SampleContent") }
 
-    def features
-      @resource_features
-    end
+    scope :image, lambda { human_code_match(:resource_mode, "Image") }
+    scope :text, lambda { human_code_match(:resource_mode, "Text") }
 
     def caption_feature
       self.features.caption.first
@@ -183,10 +131,5 @@ module ONIX
         self.caption_feature.value
       end
     end
-
-    def target_audience
-      @content_audience
-    end
-
   end
 end