im_onix 1.0.2

data/lib/onix/product_supply.rb

@@ -0,0 +1,89 @@
+require 'onix/price'
+require 'onix/date'
+
+module ONIX
+
+  class Market < SubsetDSL
+    element "Territory", :subset
+  end
+
+  class MarketPublishingDetail < SubsetDSL
+    elements "PublisherRepresentative", :subset, {:klass=>"Agent"}
+    element "MarketPublishingStatus", :subset
+    elements "MarketDate", :subset
+
+    def availability_date
+      av=@market_dates.availability.first
+      if av
+        av.date
+      else
+        nil
+      end
+    end
+  end
+
+  class SupplyDetail < SubsetDSL
+    elements "Supplier", :subset
+    element "ProductAvailability", :subset
+    elements "SupplyDate", :subset
+    elements "Price", :subset
+    element "UnpricedItemType", :subset
+
+    def availability
+      @product_availability
+    end
+
+    def distributors
+      @suppliers.select{|s| s.role.human=~/Distributor/}.uniq
+    end
+
+    def available?
+      ["Available","NotYetAvailable","InStock","ToOrder","Pod"].include?(@product_availability.human)
+    end
+
+    def sold_separately?
+      @product_availability.human!="NotSoldSeparately"
+    end
+
+    def availability_date
+      av=@supply_dates.availability.first
+      if av
+        av.date
+      else
+        nil
+      end
+    end
+  end
+
+  class ProductSupply < SubsetDSL
+    elements "Market", :subset
+    element "MarketPublishingDetail", :subset
+    elements "SupplyDetail", :subset
+
+    def availability_date
+      if @market_publishing_detail
+        @market_publishing_detail.availability_date
+      end
+    end
+
+    def countries
+      @markets.map{|m| m.territory.countries}.flatten.uniq
+    end
+
+    def distributors
+      @supply_details.map{|sd| sd.distributors}.flatten.uniq{|d| d.name}
+    end
+
+    def available_supply_details
+      @supply_details.select{|sd| sd.available?}
+    end
+
+    def unavailable_supply_details
+      @supply_details.delete_if{|sd| sd.available?}
+    end
+
+    def available?
+      self.available_supply_details.length > 0
+    end
+  end
+end

data/lib/onix/publishing_detail.rb

@@ -0,0 +1,86 @@
+require 'onix/sales_rights'
+require 'onix/date'
+module ONIX
+  class PublishingDetail < SubsetDSL
+    elements "Imprint", :subset
+    elements "Publisher", :subset
+    element "CityOfPublication", :text
+    element "CountryOfPublication", :text
+    element "PublishingStatus", :subset
+    elements "PublishingDate", :subset
+    elements "SalesRights", :subset, {:pluralize=>false}
+    element "ROWSalesRightsType", :subset, {:klass=>"SalesRightsType"}
+    element "SalesRestriction", :subset
+
+    def publisher
+      main_publishers = @publishers.select { |p| p.role.human=="Publisher" }
+      return nil if main_publishers.empty?
+      if main_publishers.length == 1
+        main_publishers.first
+      else
+        raise ExpectsOneButHasSeveral, main_publishers.map(&:name)
+      end
+    end
+
+    def imprint
+      if @imprints.length > 0
+        if @imprints.length==1
+          @imprints.first
+        else
+          raise ExpectsOneButHasSeveral, @imprints.map(&:name)
+        end
+      else
+        nil
+      end
+    end
+
+    def publication_date
+      pub=@publishing_dates.publication.first
+      if pub
+        pub.date
+      else
+        nil
+      end
+    end
+
+    def embargo_date
+      pub=@publishing_dates.embargo.first
+      if pub
+        pub.date
+      else
+        nil
+      end
+    end
+
+    def preorder_embargo_date
+      pub=@publishing_dates.preorder_embargo.first
+      if pub
+        pub.date
+      else
+        nil
+      end
+    end
+
+    def public_announcement_date
+      pub=@publishing_dates.public_announcement.first
+      if pub
+        pub.date
+      else
+        nil
+      end
+    end
+
+    def status
+      @publising_status
+    end
+
+    def city
+      @city_of_publication
+    end
+
+    def country
+      @country_of_publication
+    end
+
+  end
+end

data/lib/onix/related_material.rb

@@ -0,0 +1,30 @@
+require 'onix/related_product'
+require 'onix/related_work'
+module ONIX
+  class RelatedMaterial < SubsetDSL
+    elements "RelatedWork", :subset
+    elements "RelatedProduct", :subset
+
+    def linking(human)
+      @related_products.select{|rp| rp.code.human==human}
+    end
+
+    # :category: High level
+    # print products RelatedProduct array
+    def print_products
+      linking("EpublicationBasedOnPrintProduct") + self.alternative_format_products.select{|rp| rp.form && rp.form.code=~/^B/}
+    end
+
+    # :category: High level
+    # is part of products RelatedProduct array
+    def part_of_products
+      linking("IsPartOf")
+    end
+
+    # :category: High level
+    # alternative format products RelatedProduct array
+    def alternative_format_products
+      linking("AlternativeFormat")
+    end
+  end
+end

data/lib/onix/related_product.rb

@@ -0,0 +1,45 @@
+module ONIX
+  class RelatedProduct < SubsetDSL
+    include EanMethods
+    include ProprietaryIdMethods
+
+    element "ProductRelationCode", :subset
+    elements "ProductIdentifier", :subset
+    element "ProductForm", :subset
+    elements "ProductFormDetail", :subset
+
+    # shortcuts
+    def code
+      @product_relation_code
+    end
+
+    def identifiers
+      @product_identifiers
+    end
+
+    def form
+      @product_form
+    end
+
+    def form_details
+      @product_form_details
+    end
+
+    # full Product if referenced in ONIXMessage
+    def product
+      @product
+    end
+
+    def product=v
+      @product=v
+    end
+
+    def file_format
+      file_formats.first.human if file_formats.first
+    end
+
+    def file_formats
+      @product_form_details.select{|fd| fd.code =~ /^E1.*/}
+    end
+  end
+end

data/lib/onix/related_work.rb

@@ -0,0 +1,24 @@
+module ONIX
+  class RelatedWork < SubsetDSL
+    include EanMethods
+    element "WorkRelationCode", :subset
+    elements "WorkIdentifier", :subset
+
+    def code
+      @work_relation_code
+    end
+
+    def identifiers
+      @work_identifiers
+    end
+
+    # full Product if referenced in ONIXMessage
+    def product
+      @product
+    end
+
+    def product=v
+      @product=v
+    end
+  end
+end

data/lib/onix/sales_outlet.rb

@@ -0,0 +1,14 @@
+module ONIX
+  class SalesOutlet < SubsetDSL
+    element "SalesOutletIdentifier", :subset
+    element "SalesOutletName", :text
+
+    def identifier
+      @sales_outlet_identifier
+    end
+
+    def name
+      @sales_outlet_name
+    end
+  end
+end

data/lib/onix/sales_restriction.rb

@@ -0,0 +1,37 @@
+require 'onix/sales_outlet'
+module ONIX
+  class SalesRestriction < SubsetDSL
+    element "SalesRestrictionType", :subset
+    elements "SalesOutlet", :subset
+    element "SalesRestrictionNote", :text
+
+    attr_accessor :start_date, :end_date
+
+    # shortcuts
+    def type
+      @sales_restriction_type
+    end
+
+    def note
+      @sales_restriction_note
+    end
+
+    def initialize
+      @sales_outlets=[]
+    end
+
+    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
+    end
+  end
+end

data/lib/onix/sales_rights.rb

@@ -0,0 +1,12 @@
+require 'onix/sales_restriction'
+module ONIX
+  class SalesRights < SubsetDSL
+    element "SalesRightsType", :subset
+    element "Territory", :subset
+    elements "SalesRestriction", :subset
+
+    def type
+      @sales_rights_type
+    end
+  end
+end

data/lib/onix/subject.rb

@@ -0,0 +1,35 @@
+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
+  end
+end

data/lib/onix/subset.rb

@@ -0,0 +1,334 @@
+module ONIX
+  class ShortToRef
+    def self.names
+      @shortnames||=YAML.load(File.open(File.dirname(__FILE__) + "/../../data/shortnames.yml"))
+    end
+  end
+
+  class RefToShort
+    def self.names
+      @refnames||=ShortToRef.names.invert
+    end
+  end
+
+  TagNameMatcher = Struct.new(:tag_name) do
+    def ===(target)
+      if target.element?
+        name=target.name
+        name.casecmp(tag_name) == 0 or ShortToRef.names[name] == tag_name
+      else
+        false
+      end
+    end
+  end
+
+  class Subset
+    # instanciate Subset form Nokogiri::XML::Element
+    def self.parse(n)
+      o=self.new
+      o.parse(n)
+      o
+    end
+
+    # parse Nokogiri::XML::Element
+    def parse(n)
+    end
+
+    def unsupported(tag)
+#      raise SubsetUnsupported,tag.name
+#      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{ShortToRef.names[tag.name]})"
+    end
+
+    def tag_match(v)
+      TagNameMatcher.new(v)
+    end
+
+    def self.tag_match(v)
+      TagNameMatcher.new(v)
+    end
+
+  end
+
+  class ElementParser
+    attr_accessor :type, :name, :short
+
+    def self.inflectors
+      [['ox', 'oxes'],
+       ['us', 'uses'],
+       ['', 's'],
+       ['ero', 'eroes'],
+       ['rf', 'rves'],
+       ['af', 'aves'],
+       ['ero', 'eroes'],
+       ['man', 'men'],
+       ['ch', 'ches'],
+       ['sh', 'shes'],
+       ['ss', 'sses'],
+       ['ta', 'tum'],
+       ['ia', 'ium'],
+       ['ra', 'rum'],
+       ['ay', 'ays'],
+       ['ey', 'eys'],
+       ['oy', 'oys'],
+       ['uy', 'uys'],
+       ['y', 'ies'],
+       ['x', 'xes'],
+       ['lf', 'lves'],
+       ['ffe', 'ffes'],
+       ['afe', 'aves'],
+       ['ouse', 'ouses']]
+    end
+
+    def initialize(name, type, options={})
+      @name=name
+      @type=type
+      @pluralize=true
+      @short = false
+      @array=false
+      @parse_lambda = nil
+      @serialize_lambda = nil
+      if options[:array]
+        @array=true
+      end
+      if options[:pluralize]==false
+        @pluralize=false
+      end
+
+      @parse_lambda=options[:parse_lambda]
+      @serialize_lambda=options[:serialize_lambda]
+
+      if options[:klass]
+        @klass_name=options[:klass]
+      else
+        @klass_name=name
+      end
+    end
+
+    def parse_lambda(v)
+      if @parse_lambda
+        @parse_lambda.call(v)
+      else
+        v
+      end
+    end
+
+    def serialize_lambda(v)
+      if @serialize_lambda
+        @serialize_lambda.call(v)
+      else
+        v
+      end
+    end
+
+    def is_array?
+      @array
+    end
+
+    def _underscore_name
+      if @array and @pluralize
+        pluralize(underscore(@name))
+      else
+        underscore(@name)
+      end
+    end
+
+    def underscore_name
+      @underscore_name||=_underscore_name
+    end
+
+    def class_name
+      @klass_name
+    end
+
+    def to_sym
+      @sym||=self.underscore_name.to_sym
+    end
+
+    def to_instance
+      @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]
+      str.sub(rex) { |m| hash[m] }
+    end
+
+    def underscore(str)
+      word = str.to_s.dup
+      word.gsub!('::', '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+
+  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
+          })
+      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 })
+      end
+    end
+  end
+
+  class SubsetDSL < Subset
+    def self.scope(name, lambda)
+      @scopes ||= {}
+      @scopes[name] = lambda
+    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
+      end
+      els
+    end
+
+    def self.ancestor_registered_scopes
+      @ancestors_registered_scopes||=_ancestor_registered_scopes
+    end
+
+    def self.registered_scopes
+      @scopes||{}
+    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
+      end
+      attr_accessor @elements[name].to_sym
+    end
+
+    # shortcut for element :array=>true
+    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
+      while sup.respond_to?(:registered_elements)
+        els.merge!(sup.registered_elements) if sup.registered_elements
+        sup=sup.superclass
+      end
+      els
+    end
+
+    def self.ancestors_registered_elements
+      @ancestors_registered_elements||=_ancestors_registered_elements
+    end
+
+    def self.registered_elements
+      @elements||{}
+    end
+
+    def initialize
+      # initialize plural as Array
+      self.class.ancestors_registered_elements.each do |k, 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)
+        end
+      end
+    end
+
+    def self.short_to_ref(name)
+      ShortToRef.names[name]
+    end
+
+    def self.ref_to_short(name)
+      RefToShort.names[name]
+    end
+
+    def self.get_class(name)
+      ONIX.const_get(name) if ONIX.const_defined? name
+    end
+
+    def parse(n)
+      n.elements.each do |t|
+        name = t.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
+          end
+          if val
+            if e.is_array?
+              instance_variable_get(e.to_instance).send(:push, val)
+            else
+              instance_variable_set(e.to_instance, e.parse_lambda(val))
+            end
+          end
+        else
+          unsupported(t)
+        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