im_onix 1.0.2 → 1.1.1

data/lib/onix/onix_message.rb

@@ -1,54 +1,16 @@
 require 'nokogiri'
-require 'pp'
 require 'time'
-require 'benchmark'
 
 require 'onix/subset'
-
 require 'onix/helper'
 require 'onix/code'
-require 'onix/contributor'
-require 'onix/product_supply'
+require 'onix/sender'
+require 'onix/addressee'
 require 'onix/product'
 
 require 'onix/onix21'
 
 module ONIX
-
-  class Sender < SubsetDSL
-    include GlnMethods
-
-    elements "SenderIdentifier", :subset
-    element "SenderName", :text
-    element "ContactName", :text
-    element "EmailAddress", :text
-
-    # shortcuts
-    def identifiers
-      @sender_identifiers
-    end
-
-    def name
-      @sender_name
-    end
-  end
-
-  class Addressee < SubsetDSL
-    include GlnMethods
-
-    elements "AddresseeIdentifier", :subset
-    element "AddresseeName", :text
-
-    # shortcuts
-    def identifiers
-      @addressee_identifiers
-    end
-
-    def name
-      @addressee_name
-    end
-  end
-
   class ONIXMessage < Subset
     attr_accessor :sender, :adressee, :sent_date_time,
                   :default_language_of_text, :default_currency_code,
@@ -56,8 +18,8 @@ module ONIX
                   :release
 
     def initialize
-      @products=[]
-      @vault={}
+      @products = []
+      @vault = {}
     end
 
     def vault
@@ -71,8 +33,8 @@ module ONIX
     # merge another message in this one
     # current object erase other values
     def merge!(other)
-      @products+=other.products
-      @products=@products.uniq { |p| p.ean }
+      @products += other.products
+      @products = @products.uniq { |p| p.ean }
       init_vault
       self
     end
@@ -86,10 +48,10 @@ module ONIX
 
     # initialize hash between ID and product object
     def init_vault
-      @vault={}
+      @vault = {}
       @products.each do |product|
         product.identifiers.each do |ident|
-          @vault[ident.uniq_id]=product
+          @vault[ident.uniq_id] = product
         end
       end
 
@@ -97,7 +59,7 @@ module ONIX
         product.related.each do |rel|
           rel.identifiers.each do |ident|
             if @vault[ident.uniq_id]
-              rel.product=@vault[ident.uniq_id]
+              rel.product = @vault[ident.uniq_id]
             end
           end
         end
@@ -105,7 +67,7 @@ module ONIX
         product.parts.each do |prt|
           prt.identifiers.each do |ident|
             if @vault[ident.uniq_id]
-              prt.product=@vault[ident.uniq_id]
+              prt.product = @vault[ident.uniq_id]
             end
           end
         end
@@ -113,75 +75,100 @@ module ONIX
     end
 
     # open with arg detection
-    def open(arg, force_encoding=nil)
-      data=ONIX::Helper.arg_to_data(arg)
+    def open(arg, force_encoding = nil)
+      data = ONIX::Helper.arg_to_data(arg)
 
-      xml=nil
+      xml = nil
       if force_encoding
-        xml=Nokogiri::XML.parse(data, nil, force_encoding)
+        xml = Nokogiri::XML.parse(data, nil, force_encoding)
       else
-        xml=Nokogiri::XML.parse(data)
+        xml = Nokogiri::XML.parse(data)
       end
 
       xml.remove_namespaces!
       xml
     end
 
-    # parse filename or file
-    def parse(arg, force_encoding=nil, force_release=nil)
+    # release as an integer eg: 210, 300, 301
+    def version
+      if @release
+        @release.gsub(/\./, "").to_i * 10 ** (3 - @release.scan(".").length - 1)
+      end
+    end
+
+    # detect ONIX version from XML tags
+    def detect_release(element)
+      if element
+        return "3.0" if element.search("//DescriptiveDetail").length > 0
+        return "3.0" if element.search("//CollateralDetail").length > 0
+        return "3.0" if element.search("//ContentDetail").length > 0
+        return "3.0" if element.search("//PublishingDetail").length > 0
+      end
+      "2.1"
+    end
 
-      xml=open(arg, force_encoding)
-      @products=[]
+    def set_release_from_xml(node, force_release)
+      @release = node["release"]
+      unless @release
+        @release = detect_release(node)
+      end
+      if force_release
+        @release = force_release.to_s
+      end
+    end
 
+    # parse filename or file
+    def parse(arg, force_encoding = nil, force_release = nil)
+      xml = open(arg, force_encoding)
+      @products = []
       root = xml.root
+      set_release_from_xml(root, force_release)
       case root
-        when tag_match("ONIXMessage")
-          @release=root["release"]
-          if force_release
-            @release=force_release.to_s
-          end
-          root.elements.each do |e|
-            case e
-              when tag_match("Header")
-                e.elements.each do |t|
-                  case t
-                    when tag_match("Sender")
-                      @sender=Sender.parse(t)
-                    when tag_match("Addressee")
-                      @addressee=Addressee.parse(t)
-                    when tag_match("SentDateTime")
-                      tm=t.text
-                      @sent_date_time=Time.strptime(tm, "%Y%m%dT%H%M%S") rescue Time.strptime(tm, "%Y%m%dT%H%M") rescue Time.strptime(tm, "%Y%m%d") rescue nil
-                    when tag_match("DefaultLanguageOfText")
-                      @default_language_of_text=LanguageCode.parse(t)
-                    when tag_match("DefaultCurrencyCode")
-                      @default_currency_code=t.text
-                    else
-                      unsupported(t)
-                  end
-                end
-              when tag_match("Product")
-                product=nil
-                if @release =~ /^3.0/
-                  product=Product.parse(e)
-                else
-                  product=ONIX21::Product.parse(e)
-                end
-                product.default_language_of_text=@default_language_of_text
-                product.default_currency_code=@default_currency_code
-                @products << product
+      when tag_match("ONIXMessage")
+        root.elements.each do |e|
+          case e
+          when tag_match("Header")
+            e.elements.each do |t|
+              case t
+              when tag_match("Sender")
+                @sender = Sender.parse(t)
+              when tag_match("Addressee")
+                @addressee = Addressee.parse(t)
+              when tag_match("SentDateTime")
+                tm = t.text
+                @sent_date_time = Time.strptime(tm, "%Y%m%dT%H%M%S") rescue Time.strptime(tm, "%Y%m%dT%H%M") rescue Time.strptime(tm, "%Y%m%d") rescue nil
+              when tag_match("DefaultLanguageOfText")
+                @default_language_of_text = LanguageCode.parse(t)
+              when tag_match("DefaultCurrencyCode")
+                @default_currency_code = t.text
+              else
+                unsupported(t)
+              end
             end
+          when tag_match("Product")
+            product = nil
+            if self.version >= 300
+              product = Product.parse(e)
+            else
+              product = ONIX21::Product.parse(e)
+            end
+            product.default_language_of_text = @default_language_of_text
+            product.default_currency_code = @default_currency_code
+            @products << product
           end
-
-        when tag_match("Product")
-          product=Product.parse(xml.root)
-          product.default_language_of_text=@default_language_of_text
-          product.default_currency_code=@default_currency_code
-          @products << product
+        end
+      when tag_match("Product")
+        product = nil
+        if self.version >= 300
+          product = Product.parse(root)
+        else
+          product = ONIX21::Product.parse(root)
+        end
+        product.default_language_of_text = @default_language_of_text
+        product.default_currency_code = @default_currency_code
+        @products << product
       end
-
       init_vault
     end
   end
-
 end

data/lib/onix/price.rb

@@ -4,71 +4,51 @@ require 'onix/date'
 
 module ONIX
   class Price < SubsetDSL
-    element "PriceType", :subset
-    element "PriceQualifier", :subset
-    element "DiscountCoded", :subset
+    element "PriceType", :subset, :shortcut => :type
+    element "PriceQualifier", :subset, :shortcut => :qualifier
+    element "DiscountCoded", :subset, :shortcut => :discount
     element "PriceStatus", :subset
-    elements "PriceDate", :subset
+    elements "PriceDate", :subset, :shortcut => :dates
     element "PriceAmount", :float,
             {
-                :parse_lambda => lambda { |v| (v*100).round },
-                :serialize_lambda => lambda {|v| v/100.0}
+                :shortcut => :amount,
+                :parse_lambda => lambda { |v| (v * 100).round },
+                :serialize_lambda => lambda { |v| v / 100.0 }
             }
     element "Tax", :subset
-    element "CurrencyCode", :text
+    element "CurrencyCode", :text, :shortcut => :currency
     element "Territory", :subset
 
-    # shortcuts
-    def dates
-      @price_dates
-    end
-
-    def amount
-      @price_amount
-    end
-
-    def type
-      @price_type
-    end
-
-    def currency
-      @currency_code
-    end
-
-    def qualifier
-      @price_qualifier
-    end
-
-    def discount
-      @discount_coded
-    end
+    # @!group High level
 
+    # price from date
+    # @return [Date]
     def from_date
-      dt=@price_dates.from_date.first
+      dt = @price_dates.from_date.first
       if dt
         dt.date
-      else
-        nil
       end
     end
 
+    # price until date
+    # @return [Date]
     def until_date
-      dt=@price_dates.until_date.first
+      dt = @price_dates.until_date.first
       if dt
         dt.date
-      else
-        nil
       end
     end
 
+    # does the price include taxes ?
+    # @return [Boolean]
     def including_tax?
-      if self.type.human=~/IncludingTax/
+      if self.type.human =~ /IncludingTax/
         true
       else
         false
       end
     end
 
+    # @!endgroup
   end
-
 end

data/lib/onix/product.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'onix/helper'
 require 'onix/code'
 require 'onix/entity'
@@ -6,676 +7,205 @@ require 'onix/publishing_detail'
 require 'onix/collateral_detail'
 require 'onix/related_material'
 require 'onix/supporting_resource'
-require 'onix/subject'
-require 'onix/contributor'
 require 'onix/product_supply'
 require 'onix/territory'
 require 'onix/error'
+require 'onix/product_supplies_extractor'
 
 module ONIX
-  # flattened supplies extractor
-  module ProductSuppliesExtractor
-    # class must define a product_supplies returning an Array of objects responding to :
-    # - availability_date (Date)
-    # - countries (country code Array)
-
-    # :category: High level
-    # flattened supplies with prices
-    #
-    # supplies is a hash symbol array in the form :
-    #   [{:available=>bool,
-    #     :availability_date=>date,
-    #     :including_tax=>bool,
-    #     :currency=>string,
-    #     :territory=>string,
-    #     :suppliers=>[Supplier,...],
-    #     :prices=>[{:amount=>int,
-    #                :from_date=>date,
-    #                :until_date=>date,
-    #                :tax=>{:amount=>int, :rate_percent=>float}}]}]
-    def supplies(keep_all_prices_dates=false)
-      supplies=[]
-
-      # add territories if missing
-      if self.product_supplies
-        self.product_supplies.each do |ps|
-          ps.supply_details.each do |sd|
-            sd.prices.each do |p|
-              supply={}
-              supply[:suppliers]=sd.suppliers
-              supply[:available]=sd.available?
-              supply[:availability_date]=sd.availability_date
-
-              unless supply[:availability_date]
-                  if ps.availability_date
-                    supply[:availability_date]=ps.market_publishing_detail.availability_date
-                  end
-              end
-              supply[:price]=p.amount
-              supply[:qualifier]=p.qualifier.human if p.qualifier
-              supply[:including_tax]=p.including_tax?
-              if !p.territory or p.territory.countries.length==0
-                supply[:territory]=[]
-                supply[:territory]=ps.countries
-
-                if supply[:territory].length==0
-                  if @publishing_detail
-                    supply[:territory]=self.countries_rights
-                  end
-                end
-              else
-                supply[:territory]=p.territory.countries
-              end
-              supply[:from_date]=p.from_date
-              supply[:until_date]=p.until_date
-              supply[:currency]=p.currency
-              supply[:tax]=p.tax
-
-              unless supply[:availability_date]
-                if @publishing_detail
-                  supply[:availability_date]=@publishing_detail.publication_date
-                end
-              end
-
-              supplies << supply
-            end
-          end
-        end
-      end
-
-      grouped_supplies={}
-      supplies.each do |supply|
-        pr_key="#{supply[:available]}_#{supply[:including_tax]}_#{supply[:currency]}_#{supply[:territory].join('_')}"
-        grouped_supplies[pr_key]||=[]
-        grouped_supplies[pr_key] << supply
-      end
-
-      nb_suppliers = supplies.map{|s| s[:suppliers][0].name}.uniq.length
-      # render prices sequentially with dates
-      grouped_supplies.each do |ksup, supply|
-        if supply.length > 1
-          global_price=supply.select{|p| not p[:from_date] and not p[:until_date]}
-          global_price=global_price.first
-
-          if global_price
-            if nb_suppliers > 1
-              grouped_supplies[ksup] += self.prices_with_periods(supply, global_price)
-            else
-              grouped_supplies[ksup] = self.prices_with_periods(supply, global_price)
-            end
-            grouped_supplies[ksup].uniq!
-          else
-            # remove explicit from date
-            explicit_from=supply.select{|p| p[:from_date] and not supply.select{|sp| sp[:until_date] and sp[:until_date]<=p[:from_date]}.first}.first
-            if explicit_from
-              explicit_from[:from_date]=nil unless keep_all_prices_dates
-            end
-          end
-
-
-        else
-          supply.each do |s|
-            if s[:from_date] and s[:availability_date] and s[:from_date] >= s[:availability_date]
-              s[:availability_date]=s[:from_date]
-            end
-            s[:from_date]=nil unless keep_all_prices_dates
-
-          end
-        end
-      end
-
-      # merge by territories
-      grouped_territories_supplies={}
-      grouped_supplies.each do |ksup,supply|
-        fsupply=supply.first
-        pr_key="#{fsupply[:available]}_#{fsupply[:including_tax]}_#{fsupply[:currency]}"
-        supply.each do |s|
-          pr_key+="_#{s[:price]}_#{s[:from_date]}_#{s[:until_date]}"
-        end
-        grouped_territories_supplies[pr_key]||=[]
-        grouped_territories_supplies[pr_key] << supply
-      end
-
-      supplies=[]
-
-      grouped_territories_supplies.each do |ksup,supply|
-        fsupply=supply.first.first
-        supplies << {:including_tax=>fsupply[:including_tax],:currency=>fsupply[:currency],
-                     :territory=>supply.map{|fs| fs.map{|s| s[:territory]}}.flatten.uniq,
-                     :available=>fsupply[:available],
-                     :availability_date=>fsupply[:availability_date],
-                     :suppliers=>fsupply[:suppliers],
-                     :prices=>supply.first.map{|s|
-
-                       s[:amount]=s[:price]
-                       s.delete(:price)
-                       s.delete(:available)
-                       s.delete(:currency)
-                       s.delete(:availability_date)
-                       s.delete(:including_tax)
-                       s.delete(:territory)
-                       s
-                     }}
-      end
-
-      supplies
-    end
-
-    # add missing periods when they can be guessed
-    def prices_with_periods(supplies, global_supply)
-      complete_supplies = supplies.select{ |supply| supply[:from_date] && supply[:until_date] }.sort_by { |supply| supply[:from_date] }
-      missing_start_period_supplies = supplies.select{ |supply| supply[:from_date] && !supply[:until_date] }.sort_by { |supply| supply[:from_date] }
-      missing_end_period_supplies = supplies.select{ |supply| !supply[:from_date] && supply[:until_date] }.sort_by { |supply| supply[:until_date] }
-
-      return [global_supply] if [complete_supplies, missing_start_period_supplies, missing_end_period_supplies].all? {|supply| supply.empty? }
-
-      return self.add_missing_periods(complete_supplies, global_supply) unless complete_supplies.empty?
-
-      without_start = missing_start_period_supplies.length == 1 && complete_supplies.empty? && missing_end_period_supplies.empty?
-      without_end = missing_end_period_supplies.length == 1 && complete_supplies.empty? && missing_start_period_supplies.empty?
-
-      return self.add_starting_period(missing_start_period_supplies.first, global_supply) if without_start
-      return self.add_ending_period(missing_end_period_supplies.first, global_supply) if without_end
-
-      [global_supply]
-    end
-
-    def add_missing_periods(supplies, global_supply)
-      new_supplies = []
-
-      supplies.each.with_index do |supply, index|
-        new_supplies << global_supply.dup.tap{ |start_sup| start_sup[:until_date] = supply[:from_date] - 1 } if index == 0
-
-        if index > 0 && index != supplies.length
-          new_supplies << global_supply.dup.tap do |missing_supply|
-            missing_supply[:from_date] = supplies[index - 1][:until_date] + 1
-            missing_supply[:until_date] = supply[:from_date] - 1
-          end
-        end
-
-        new_supplies << supply
-
-        new_supplies << global_supply.dup.tap{ |end_sup| end_sup[:from_date] = supply[:until_date] + 1 } if index == supplies.length - 1
-      end
-
-      new_supplies
-    end
-
-    def add_starting_period(supply, global_supply)
-      missing_supply = global_supply.dup
-      missing_supply[:until_date] = supply[:from_date] - 1
-
-      [missing_supply, supply]
-    end
-
-    def add_ending_period(supply, global_supply)
-      missing_supply = global_supply.dup
-      missing_supply[:from_date] = supply[:until_date] + 1
-
-      [supply, missing_supply]
-    end
-
-    # :category: High level
-    # flattened supplies only including taxes
-    def supplies_including_tax
-      self.supplies.select{|p| p[:including_tax]}
-    end
-
-    # :category: High level
-    # flattened supplies only excluding taxes
-    def supplies_excluding_tax
-      self.supplies.select{|p| not p[:including_tax]}
-    end
-
-    # :category: High level
-    # flattened supplies with default tax (excluding tax for US and CA, including otherwise)
-    def supplies_with_default_tax
-      self.supplies_including_tax + self.supplies_excluding_tax.select{|s| ["CAD","USD"].include?(s[:currency])}
-    end
-
-    # :category: High level
-    # flattened supplies for country
-    def supplies_for_country(country,currency=nil)
-      country_supplies=self.supplies
-      if currency
-        country_supplies=country_supplies.select{|s| s[:currency]==currency}
-      end
-      country_supplies.select{|s|
-        if s[:territory].include?(country)
-          true
-        else
-          false
-        end
-      }
-    end
-
-    # :category: High level
-    # price amount for given +currency+ and country at time
-    def at_time_price_amount_for(time,currency,country=nil)
-      sups=self.supplies_with_default_tax.select { |p| p[:currency]==currency }
-      if country
-        sups=sups.select{|p| p[:territory].include?(country)}
-      end
-      if sups.length > 0
-        # exclusive
-        sup=sups.first[:prices].select { |p|
-          (!p[:from_date] or p[:from_date].to_date <= time.to_date) and
-              (!p[:until_date] or p[:until_date].to_date > time.to_date)
-        }.first
-
-        if sup
-          sup[:amount]
-        else
-          # or inclusive
-          sup=sups.first[:prices].select { |p|
-            (!p[:from_date] or p[:from_date].to_date <= time.to_date) and
-                (!p[:until_date] or p[:until_date].to_date >= time.to_date)
-          }.first
-
-          if sup
-            sup[:amount]
-          else
-            nil
-          end
-        end
-
-      else
-        nil
-      end
-    end
-
-    # :category: High level
-    # current price amount for given +currency+ and country
-    def current_price_amount_for(currency,country=nil)
-      at_time_price_amount_for(Time.now,currency,country)
-    end
-  end
-
   class Product < SubsetDSL
+    extend Forwardable
     include EanMethods
     include IsbnMethods
     include ProprietaryIdMethods
+    include ProductSuppliesExtractor
 
     element "RecordReference", :text
     element "NotificationType", :subset
     element "RecordSourceName", :text
-    elements "ProductIdentifier", :subset
+    elements "ProductIdentifier", :subset, :shortcut => :identifiers
     element "DescriptiveDetail", :subset
     element "CollateralDetail", :subset
     element "PublishingDetail", :subset
     element "RelatedMaterial", :subset
     elements "ProductSupply", :subset
 
-    # shortcuts
-    def identifiers
-      @product_identifiers
-    end
-
     # default LanguageCode from ONIXMessage
     attr_accessor :default_language_of_text
     # default code from ONIXMessage
     attr_accessor :default_currency_code
 
-    include ProductSuppliesExtractor
-
-    # :category: High level
-    # product title string
-    def title
-      @descriptive_detail.title
-    end
-
-    # :category: High level
-    # product subtitle string
-    def subtitle
-      @descriptive_detail.subtitle
-    end
-
-    # :category: High level
-    # product description string including HTML
-    def description
-      if @collateral_detail
-        @collateral_detail.description
-      else
-        nil
-      end
-    end
+    # @!group Shortcuts
 
-    # :category: High level
-    # product larger front cover URL string
-    def frontcover_url
-      if @collateral_detail
-        @collateral_detail.frontcover_url
-      end
-    end
-
-    # :category: High level
-    # product larger front cover last updated date
-    def frontcover_last_updated
-      if @collateral_detail
-        @collateral_detail.frontcover_last_updated
-      end
-    end
-
-    # :category: High level
-    # product larger front cover mimetype
-    def frontcover_mimetype
-      if @collateral_detail
-        @collateral_detail.frontcover_mimetype
-      end
-    end
-
-    # :category: High level
-    # ePub sample URL string
-    def epub_sample_url
-      if @collateral_detail
-        @collateral_detail.epub_sample_url
-      end
-    end
-
-    # :category: High level
-    # ePub sample last updated date
-    def epub_sample_last_updated
-      if @collateral_detail
-        @collateral_detail.epub_sample_last_updated
-      end
-    end
-
-    # :category: High level
-    # ePub sample mimetype
-    def epub_sample_mimetype
-      if @collateral_detail
-        @collateral_detail.epub_sample_mimetype
-      end
-    end
-
-    # :category: High level
-    # product edition number
-    def edition_number
-      @descriptive_detail.edition_number
-    end
+    # @return (see PublishingDetail#publishers)
+    def publishers
+      @publishing_detail ? @publishing_detail.publishers : []
+    end
+
+    # !@endgroup
+
+    # @!group High level
+
+    def_delegator :descriptive_detail, :title
+    def_delegator :descriptive_detail, :subtitle
+    def_delegator :descriptive_detail, :edition_number
+    def_delegator :descriptive_detail, :publisher_collection_title
+    def_delegator :descriptive_detail, :bisac_categories # deprecated
+    def_delegator :descriptive_detail, :clil_categories # deprecated
+    def_delegator :descriptive_detail, :bisac_categories_codes
+    def_delegator :descriptive_detail, :clil_categories_codes
+    def_delegator :descriptive_detail, :keywords
+    def_delegator :descriptive_detail, :protection_type
+    def_delegator :descriptive_detail, :protections
+    def_delegator :descriptive_detail, :drmized?
+    def_delegator :descriptive_detail, :digital?
+    def_delegator :descriptive_detail, :audio?
+    def_delegator :descriptive_detail, :streaming?
+    def_delegator :descriptive_detail, :bundle?
+    def_delegator :descriptive_detail, :parts
+    def_delegator :descriptive_detail, :filesize
+    def_delegator :descriptive_detail, :audio_formats
+    def_delegator :descriptive_detail, :audio_format
+    def_delegator :descriptive_detail, :file_format
+    def_delegator :descriptive_detail, :file_mimetype
+    def_delegator :descriptive_detail, :file_description
+    def_delegator :descriptive_detail, :reflowable?
+    def_delegator :descriptive_detail, :pages
+    def_delegator :descriptive_detail, :subjects
+    def_delegator :descriptive_detail, :form_details
+    def_delegator :descriptive_detail, :contributors
+
+    def_delegator :collateral_detail, :description
+    def_delegator :collateral_detail, :frontcover_url
+    def_delegator :collateral_detail, :frontcover_last_updated
+    def_delegator :collateral_detail, :frontcover_mimetype
+    def_delegator :collateral_detail, :epub_sample_url
+    def_delegator :collateral_detail, :epub_sample_last_updated
+    def_delegator :collateral_detail, :epub_sample_mimetype
+
+    def_delegator :publishing_detail, :publication_date
+    def_delegator :publishing_detail, :embargo_date
+    def_delegator :publishing_detail, :preorder_embargo_date
+    def_delegator :publishing_detail, :public_announcement_date
+    def_delegator :publishing_detail, :sales_restriction
+    def_delegator :publishing_detail, :imprint
+    def_delegator :publishing_detail, :publisher
 
     # product LanguageCode of text
     def language_of_text
       @descriptive_detail.language_of_text || @default_language_of_text
     end
 
-    # :category: High level
     # product language code string of text (eg: fre)
+    # @return [String]
     def language_code_of_text
       if self.language_of_text
         self.language_of_text.code
       end
     end
 
-    # :category: High level
     # product language name string of text (eg: French)
+    # @return [String]
     def language_name_of_text
       if self.language_of_text
         self.language_of_text.human
       end
     end
 
-    # :category: High level
-    # publisher collection title
-    def publisher_collection_title
-      @descriptive_detail.publisher_collection_title
-    end
-
-    def subjects
-      @descriptive_detail.subjects
-    end
-
-    # BISAC categories Subject
-    def bisac_categories
-      @descriptive_detail.bisac_categories
-    end
-
-    # :category: High level
-    # BISAC categories identifiers string array (eg: FIC000000)
-    def bisac_categories_codes
-      self.bisac_categories.map{|c| c.code}.uniq
-    end
-
-    # CLIL categories Subject
-    def clil_categories
-      @descriptive_detail.clil_categories
-    end
-
-    # :category: High level
-    # CLIL categories identifier string array
-    def clil_categories_codes
-      self.clil_categories.map{|c| c.code}.uniq
-    end
-
-    # :category: High level
-    # keywords string array
-    def keywords
-      @descriptive_detail.keywords
-    end
-
-    # :category: High level
-    # Protection type string (None, Watermarking, Drm, AdobeDrm)
-    def protection_type
-      @descriptive_detail.protection_type
-    end
-
-    # :category: High level
-    # List of protections type string (None, Watermarking, DRM, AdobeDRM)
-    def protections
-      @descriptive_detail.protections
-    end
-
-    # :category: High level
-    # product has DRM ?
-    def drmized?
-      if @protections.any? {|p| p =~ /Drm/ }
-        true
-      else
-        false
-      end
-    end
-
-    # :category: High level
-    # is product digital ?
-    def digital?
-      @descriptive_detail.digital?
-    end
-
-    # :category: High level
-    # is product audio ?
-    def audio?
-      @descriptive_detail.audio?
-    end
-
-    # :category: High level
-    # is product digital ?
-    def streaming?
-      @descriptive_detail.streaming?
-    end
-
-    # :category: High level
-    # is product a bundle of multiple parts ?
-    def bundle?
-      @descriptive_detail.bundle?
-    end
-
+    # product can be sold separately ?
+    # @return [Boolean]
     def sold_separately?
-      @product_supplies.map{|ps| ps.supply_details.map{|sd| sd.sold_separately?}.flatten}.flatten.uniq.first
+      @product_supplies.map { |product_supply|
+        product_supply.supply_details.map { |supply_detail| supply_detail.sold_separately? }.flatten
+      }.flatten.uniq.first
     end
 
-    # :category: High level
-    # bundle ProductPart array
-    def parts
-      @descriptive_detail.parts
-    end
-
-    # :category: High level
-    # digital file filesize in bytes
-    def filesize
-      @descriptive_detail.filesize
-    end
-
-    # :category: High level
-    # audio formats array
-    def audio_formats
-      @descriptive_detail.audio_formats
-    end
-
-    # :category: High level
-    # audio format string ()
-    def audio_format
-      @descriptive_detail.audio_format
-    end
-
-    # :category: High level
-    # digital file format string (Epub,Pdf,Mobipocket)
-    def file_format
-      @descriptive_detail.file_format
-    end
-
-    def form_details
-      @descriptive_detail.form_details
-    end
-
-    def reflowable?
-      @descriptive_detail.reflowable?
-    end
-
-    # :category: High level
-    # digital file mimetype (Epub,Pdf,Mobipocket)
-    def file_mimetype
-      @descriptive_detail.file_mimetype
-    end
-
-    # :category: High level
-    # digital file description string
-    def file_description
-      @descriptive_detail.file_description
-    end
-
-    # :category: High level
     # raw file description string without HTML
+    # @return [String]
     def raw_file_description
       if @descriptive_detail.file_description
-        Helper.strip_html(@descriptive_detail.file_description).gsub(/\s+/," ").strip
-      else
-        nil
+        Helper.strip_html(@descriptive_detail.file_description).gsub(/\s+/, " ").strip
       end
     end
 
-    # :category: High level
-    # page count
-    def pages
-      @descriptive_detail.pages
-    end
-
-    # :category: High level
     # raw book description string without HTML
+    # @return [String]
     def raw_description
       if self.description
-        Helper.strip_html(self.description).gsub(/\s+/," ").strip
-      else
-        nil
-      end
-    end
-
-    def publishers
-      if @publishing_detail
-        @publishing_detail.publishers
-      else
-        []
+        Helper.strip_html(self.description).gsub(/\s+/, " ").strip
       end
     end
 
-    def publisher
-      if @publishing_detail
-        @publishing_detail.publisher
-      else
-        nil
-      end
-    end
-
-    # :category: High level
     # publisher name string, if multiple publishers are found, then they are concatenated with " / "
+    # @return [String]
     def publisher_name
       if self.publishers.length > 0
-        self.publishers.map{|p| p.name}.join(" / ")
+        self.publishers.map { |p| p.name }.join(" / ")
       end
     end
 
-    # :category: High level
     # publisher GLN string, nil if multiple publishers are found
+    # @return [String]
     def publisher_gln
-      if self.publishers.length==1
+      if self.publishers.length == 1
         self.publisher.gln
       end
     end
 
-    def imprint
-      if @publishing_detail
-        @publishing_detail.imprint
-      else
-        nil
-      end
-    end
-
-    # :category: High level
     # imprint name string
+    # @return [String]
     def imprint_name
       if self.imprint
         self.imprint.name
-      else
-        nil
       end
     end
 
-    # :category: High level
     # imprint GLN string
+    # @return [String]
     def imprint_gln
       if self.imprint
         self.imprint.gln
       end
     end
 
+    # product distributors names
+    # @return [Array<String>]
     def distributors
-      @product_supplies.map{|ps| ps.distributors}.flatten.uniq{|d| d.name}
+      @product_supplies.map { |ps| ps.distributors }.flatten.uniq { |d| d.name }
     end
 
-    # product distributor
+    # product distributor name
+    # @return [String]
     def distributor
       if self.distributors.length > 0
-      if self.distributors.length==1
-        self.distributors.first
-      else
-        raise ExpectsOneButHasSeveral, self.distributors.map(&:name)
-      end
+        if self.distributors.length == 1
+          self.distributors.first
+        else
+          raise ExpectsOneButHasSeveral, self.distributors.map(&:name)
+        end
       else
         nil
       end
     end
 
-    # :category: High level
     # product distributor name string
+    # @return [String]
     def distributor_name
       if self.distributor
         self.distributor.name
-      else
-        nil
       end
     end
 
-    # :category: High level
     # product distributor GLN string
+    # @return [String]
     def distributor_gln
       if self.distributor
         self.distributor.gln
-      else
-        nil
       end
     end
 
-    # :category: High level
     # return every related subset
+    # @return [Array]
     def related
       if @related_material
         (@related_material.related_products + @related_material.related_works)
@@ -684,16 +214,16 @@ module ONIX
       end
     end
 
-    # :category: High level
-    # paper linking RelatedProduct
+    # first part RelatedProduct
+    # @return [RelatedProduct]
     def part_of_product
       if @related_material
         @related_material.part_of_products.first
       end
     end
 
-      # :category: High level
-    # paper linking RelatedProduct
+    # first paper linking RelatedProduct
+    # @return [RelatedProduct]
     def print_product
       if @related_material
         @related_material.print_products.first
@@ -701,146 +231,120 @@ module ONIX
     end
 
     # DEPRECATED see print_product instead
+    # @return [RelatedProduct]
     def paper_linking
       self.print_product
     end
 
-    # :category: High level
-    # date of publication
-    def publication_date
-      if @publishing_detail
-        @publishing_detail.publication_date
-      end
-    end
-
-    # date of embargo
-    def embargo_date
-      if @publishing_detail
-        @publishing_detail.embargo_date
-      end
-    end
-
-    def preorder_embargo_date
-      if @publishing_detail
-        @publishing_detail.preorder_embargo_date
-      end
-    end
-
-    def public_announcement_date
-      if @publishing_detail
-        @publishing_detail.public_announcement_date
-      end
-    end
-
-    def sales_restriction
-      if @publishing_detail
-        @publishing_detail.sales_restriction
-      end
-    end
-
-    # :category: High level
     # product countries rights string array
+    # @return [Array<String>]
     def countries_rights
-      countries=[]
+      countries = []
       if @publishing_detail
-        countries+=@publishing_detail.sales_rights.map{|sr| sr.territory.countries}.flatten.uniq
+        countries += @publishing_detail.sales_rights.map { |sale_right| sale_right.territory.countries }.flatten.uniq
       end
 
       if @product_supplies
-        countries+=@product_supplies.map{|ps| ps.markets.map{|m| m.territory.countries}.flatten}.flatten.uniq
+        countries += @product_supplies.map { |product_supply|
+          product_supply.markets.map { |market| market.territory.countries }.flatten
+        }.flatten.uniq
       end
 
       countries.uniq
     end
 
-    # :category: High level
+    # all images
     def illustrations
       return [] unless @collateral_detail && @collateral_detail.supporting_resources
 
       @collateral_detail.supporting_resources.image.map do |image_resource|
         {
-          :url => image_resource.versions.last.links.first.strip,
-          :type => image_resource.type.human,
-          :width => image_resource.versions.last.image_width,
-          :height => image_resource.versions.last.image_height,
-          :caption => image_resource.caption,
-          :format_code => image_resource.versions.last.file_format,
-          :updated_at => image_resource.versions.last.last_updated_utc
+            :url => image_resource.versions.last.links.first.strip,
+            :type => image_resource.type.human,
+            :width => image_resource.versions.last.image_width,
+            :height => image_resource.versions.last.image_height,
+            :caption => image_resource.caption,
+            :format_code => image_resource.versions.last.file_format,
+            :updated_at => image_resource.versions.last.last_updated_utc
         }
       end
     end
 
-    # :category: High level
+    # all excerpts
     def excerpts
       return [] unless @collateral_detail && @collateral_detail.supporting_resources
 
-      @collateral_detail.supporting_resources.sample_content.human_code_match(:resource_mode,["Text","Multimode"]).map do |resource|
+      @collateral_detail.supporting_resources.sample_content.human_code_match(:resource_mode, ["Text", "Multimode"]).map do |resource|
         {
-          :url => resource.versions.last.links.first.strip,
-          :form => resource.versions.last.form.human,
-          :md5 => resource.versions.last.md5_hash,
-          :format_code => resource.versions.last.file_format,
-          :updated_at => resource.versions.last.last_updated_utc
+            :url => resource.versions.last.links.first.strip,
+            :form => resource.versions.last.form.human,
+            :md5 => resource.versions.last.md5_hash,
+            :format_code => resource.versions.last.file_format,
+            :updated_at => resource.versions.last.last_updated_utc
         }
       end
     end
 
+    # available product supplies
+    # @return [Array<ProductSupply>]
     def available_product_supplies
-      @product_supplies.select{|ps| ps.available?}
+      @product_supplies.select { |product_supply| product_supply.available? }
     end
 
-    # :category: High level
     # is product available ?
+    # @return [Boolean]
     def available?
       self.available_product_supplies.length > 0 and not self.delete?
     end
 
-    # :category: High level
     # is product available for given +country+ ?
+    # @return [Boolean]
     def available_for_country?(country)
-      self.supplies_for_country(country).select{|s| s[:available]}.length > 0 and self.available?
+      self.supplies_for_country(country).select { |s| s[:available] }.length > 0 and self.available?
     end
 
-    # :category: High level
     # is product price to be announced ?
+    # @return [Boolean]
     def price_to_be_announced?
       unless self.product_supplies.empty? || self.product_supplies.first.supply_details.empty?
         unpriced_item_type = self.product_supplies.first.supply_details.first.unpriced_item_type
       end
-      unpriced_item_type ? unpriced_item_type.human=="PriceToBeAnnounced" : false
+      unpriced_item_type ? unpriced_item_type.human == "PriceToBeAnnounced" : false
     end
 
-    # :category: High level
-    # is a deletion notification ?
+    # is product a deletion notification ?
+    # @return [Boolean]
     def delete?
-      self.notification_type.human=="Delete"
-    end
-
-    # :category: High level
-    # Contributor array
-    def contributors
-      @descriptive_detail.contributors
+      self.notification_type.human == "Delete"
     end
 
-    # :category: High level
     # List of ONIX outlets values
+    # @return [Array<String>]
     def onix_outlets_values
       if @publishing_detail
-        @publishing_detail.sales_rights.map { |sri|
-          sri.sales_restrictions.select { |sr| (!sr.start_date or sr.start_date <= Date.today) and (!sr.end_date or sr.end_date >= Date.today) }.map { |sr|
-            sr.sales_outlets.select { |so|
-              so.identifier and so.identifier.type.human=="OnixSalesOutletIdCode" }.map { |so| so.identifier.value } } }.flatten
+        @publishing_detail.sales_rights.map { |sales_right|
+          sales_right.sales_restrictions.select { |sales_restriction|
+            (!sales_restriction.start_date or sales_restriction.start_date <= Date.today) and
+                (!sales_restriction.end_date or sales_restriction.end_date >= Date.today)
+          }.map { |sale_right|
+            sale_right.sales_outlets.select { |sale_outlet|
+              sale_outlet.identifier and sale_outlet.identifier.type.human == "OnixSalesOutletIdCode" }.map { |sale_outlet|
+              sale_outlet.identifier.value
+            }
+          }
+        }.flatten
       else
         []
       end
     end
 
+    # @!endgroup
+
     def parse(n)
       super
       parts.each do |part|
-        part.part_of=self
+        part.part_of = self
       end
     end
-
   end
 end