im_onix 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7eec0e1b2732af7b05abadeadeafe1c4e9acf53166b2256cbe39476461e5f99a
+  data.tar.gz: 166d34732659a91b6494d8dd1507100d861bebd7a8c258263e2d02204befdffc
+SHA512:
+  metadata.gz: e42f395bf965520563bf4697abde739bbcbfda111f8ec8c1b3a9bc5f9612bba6773a5c245c15fa442fcda75fc4a0283328dab228f387f9222be8892432527590
+  data.tar.gz: 7f941cad2dfdc9946d9c4a773d543003131178394e636fe5d4de12c408ef31f6f22dc52d802840e70d0dcd57bac73f9bc3c2aa0a83fdc6a1c2dd7bfedc6b7fcd

data/README.md

@@ -0,0 +1,39 @@
+## Pragmatic ONIX 3.0 parser for Ruby
+
+### Low level API
+Whole structure is accessible through ONIX::ONIXMessage object :
+```ruby
+message=ONIX::ONIXMessage.new
+message.parse("onix_file.xml")
+# first product
+pp message.products.first
+# first identifier of first product
+pp message.products.first.identifiers.first
+```
+
+Ruby elements variables are underscored, lowercase of ONIX tags (Product -> product, DescriptiveDetail -> descriptive_detail) and pluralized in case of array (ProductSupply -> product_supplies).
+
+### High level API
+High level methods give abstracted and simplified access to the most important data.
+See http://nu.immateriel.fr/im_onix/doc/ONIX/Product.html for high level API rdoc and onix_pp.rb, onix3_to_onix2.rb and onix3_to_onix3.rb sample in bin/
+
+Usage :
+```shell
+onix_pp.rb onix.xml
+onix3_to_onix2.rb onix.xml
+onix3_to_onix3.rb onix.xml
+```
+### Development
+
+#### Running the tests
+
+Launch this command:
+
+```
+ruby -Ilib:test test/test_im_onix.rb
+```
+
+### Contributors
+TEA "The Ebook Alternative" : http://www.tea-ebook.com/
+
+Bookmate : https://bookmate.com/

data/bin/html_codelist_to_yml.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# -*- encoding : utf-8 -*-
+
+require 'im_onix'
+require 'nokogiri'
+require 'yaml'
+
+# html_codelist_to_yml.rb html_codelist_dir
+
+class HTMLCodelist
+
+  private
+  def self.parse_codelist(codelist)
+    h={}
+#      puts "PARSE CODELIST #{codelist}"
+    html=Nokogiri::HTML.parse(File.open(codelist))
+    html.search("//tr").each do |tr|
+#        pp tr
+      td_code=tr.at("./td[1]")
+      td_human=tr.at("./td[2]")
+      if td_code and td_human
+        h[td_code.text.strip]=self.rename(td_human.text.strip)
+      end
+    end
+    h
+  end
+
+  # from rails
+  def self.rename(term)
+    term.gsub(/\(|\)|\,|\-|’|\/|“|”|‘|\.|\:|–|\||\+/,"").gsub(/\;/," Or ").gsub(/\s+/," ").split(" ").map{|t| t.capitalize}.join("")
+  end
+
+end
+
+files=`ls #{ARGV[1]}/*.htm`.split(/\n/)
+
+h={}
+
+files.sort.each do |file|
+  codelist=file.gsub(/.*onix\-codelist\-(.*)\.htm/,'\1').to_i
+  h=HTMLCodelist.parse_codelist(file)
+
+  File.open("data/codelists/codelist-#{codelist}.yml",'w') do |fw| fw.write({:codelist=>h}.to_yaml) end
+
+end
+

data/bin/onix3_to_onix2.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+require 'im_onix'
+require 'nokogiri'
+
+filename=ARGV[0]
+
+if filename
+msg=ONIX::ONIXMessage.new
+msg.parse(filename)
+
+builder = Nokogiri::XML::Builder.new(:encoding => "UTF-8") do |xml|
+  xml.doc.create_internal_subset(
+      'ONIXMessage',
+      nil,
+      "http://www.editeur.org/onix/2.1/reference/onix-international.dtd"
+  )
+  xml.ONIXMessage {
+    xml.Header {
+      if msg.sender and msg.sender.name
+        xml.FromCompany(msg.sender.name)
+      else
+        xml.FromCompany("Any")
+      end
+      xml.ToCompany("Any")
+    }
+
+msg.products.each do |product|
+  xml.Product {
+    xml.RecordReference(product.ean)
+    xml.NotificationType("03")
+
+    xml.ProductIdentifier {
+      xml.ProductIDType("03")
+      xml.IDValue(product.ean)
+
+    }
+
+    xml.ProductForm("DG")
+
+    case product.file_format
+      when "Pdf"
+        xml.EpubType("002")
+      when "Epub"
+        xml.EpubType("029")
+      else
+        xml.EpubType("000")
+    end
+
+#    if @book.book_collection
+#      xml.Series {
+#        xml.TitleOfSeries(@book.book_collection.title)
+#      }
+#    end
+
+    xml.Title {
+      xml.TitleType("01")
+      xml.TitleText(product.title)
+      if product.subtitle
+        xml.Subtitle(product.subtitle)
+      end
+    }
+
+    i=1
+    product.contributors.each do |a|
+        xml.Contributor {
+          xml.SequenceNumber(i)
+          xml.ContributorRole(a.role.code)
+          xml.PersonName(a.name)
+          if a.biography
+            xml.BiographicalNote(a.biography)
+          end
+        }
+        i=i+1
+    end
+
+#    xml.EditionNumber(@book.edition)
+
+    if product.language_of_text
+    xml.Language {
+      xml.LanguageRole("01")
+      xml.LanguageCode(product.language_of_text)
+    }
+    end
+
+    if product.pages
+      xml.NumberOfPages(product.pages)
+    end
+
+    product.bisac_categories.each do |ct|
+      xml.BASICMainSubject(ct.code)
+    end
+
+    xml.OtherText {
+      xml.TextTypeCode("01")
+      xml.Text(product.description)
+    }
+
+    if product.imprint_name
+    xml.Imprint {
+      xml.ImprintName(product.imprint_name)
+    }
+    end
+
+    xml.Publisher {
+      xml.PublishingRole("01")
+      xml.PublisherName(product.publisher_name)
+    }
+
+
+    if product.available?
+      xml.PublishingStatus("04")
+    else
+      xml.PublishingStatus("08")
+    end
+
+    xml.PublicationDate(product.publication_date.strftime("%Y%m%d"))
+
+    xml.SalesRights {
+      xml.SalesRightsType("01")
+      xml.RightsCountry(product.countries_rights.join(" "))
+    }
+
+    if product.print_product
+      xml.RelatedProduct {
+        xml.RelationCode("13")
+
+        xml.ProductIdentifier {
+          xml.ProductIDType("03")
+          xml.IDValue(product.print_product.ean)
+        }
+      }
+
+    end
+
+    product.supplies.each do |supply|
+    xml.SupplyDetail {
+      if product.distributor_name
+        xml.SupplierName(product.distributor_name)
+      else
+        xml.SupplierName("Unknown")
+      end
+
+
+      if supply[:available]
+        xml.ProductAvailability("20")
+      else
+        xml.ProductAvailability("40")
+      end
+
+      if supply[:availability_date]
+        xml.OnSaleDate(supply[:availability_date].strftime("%Y%m%d"))
+      else
+        xml.OnSaleDate(product.publication_date.strftime("%Y%m%d"))
+      end
+
+        supply[:prices].each do |price|
+          xml.Price {
+            if supply[:including_tax]
+              xml.PriceTypeCode("04")
+            else
+              xml.PriceTypeCode("03")
+            end
+            xml.PriceAmount(price[:amount]/100.0)
+            xml.CurrencyCode(supply[:currency])
+            supply[:territory].each do |t|
+              xml.CountryCode(t)
+            end
+
+            if price[:from_date] then
+              xml.PriceEffectiveFrom(price[:from_date].strftime("%Y%m%d"))
+            end
+            if price[:until_date]
+              xml.PriceEffectiveUntil(price[:until_date].strftime("%Y%m%d"))
+            end
+
+          }
+        end
+
+    }
+    end
+
+  }
+end
+  }
+
+end
+
+puts builder.to_xml
+else
+  puts "ONIX 3.0 to ONIX 2.1 converter"
+  puts "Usage: onix3_to_onix2.rb onix.xml"
+end

data/bin/onix3_to_onix3.rb

@@ -0,0 +1,401 @@
+#!/usr/bin/env ruby
+require 'im_onix'
+require 'nokogiri'
+
+filename=ARGV[0]
+
+if filename
+msg=ONIX::ONIXMessage.new
+msg.parse(filename)
+
+builder = Nokogiri::XML::Builder.new(:encoding => "UTF-8") do |xml|
+  xml.ONIXMessage(:release=>"3.0", :xmlns=>"http://ns.editeur.org/onix/3.0/reference") {
+    xml.Header {
+      if msg.sender
+        xml.Sender {
+          if msg.sender.gln
+            xml.SenderIdentifier {
+              xml.SenderIDType("06")
+              xml.IDValue(msg.sender.gln)
+            }
+          end
+          xml.SenderName(msg.sender.name)
+        }
+      end
+      if msg.sent_date_time
+        xml.SentDateTime(msg.sent_date_time.strftime("%Y%m%dT%H%M"))
+      end
+    }
+    msg.products.each do |product|
+      xml.Product {
+      xml.RecordReference(product.ean)
+      if product.delete?
+        xml.NotificationType("05")
+      else
+        xml.NotificationType("03")
+      end
+      xml.ProductIdentifier {
+        xml.ProductIDType("03")
+        xml.IDValue(product.ean)
+      }
+      product.proprietary_ids.each do |id|
+        xml.ProductIdentifier {
+          xml.ProductIDType("01")
+          if id.name
+            xml.IDTypeName(id.name)
+          end
+          xml.IDValue(id.value)
+        }
+      end
+      xml.DescriptiveDetail {
+        if product.bundle?
+          xml.ProductComposition("10")
+        else
+          xml.ProductComposition("00")
+        end
+
+        if product.digital?
+          xml.ProductForm("EA")
+        else
+          xml.ProductForm("BA")
+        end
+
+        if product.bundle?
+          product.parts.each do |part|
+            xml.ProductPart {
+              xml.ProductIdentifier {
+                xml.ProductIDType("03")
+                xml.IDValue(part.ean)
+              }
+
+              if part.file_format
+              xml.ProductForm("EA")
+              case part.file_format
+                when "Epub"
+                  xml.ProductFormDetail("E101")
+                when "Pdf"
+                  xml.ProductFormDetail("E107")
+                when "Mobipocket"
+                  xml.ProductFormDetail("E127")
+                else
+                  xml.ProductFormDetail("E100")
+                  xml.ProductFormDescription(part.file_description)
+
+              end
+
+              end
+              xml.NumberOfCopies("1")
+
+            }
+          end
+        else
+          if product.digital?
+          case product.file_format
+            when "Epub"
+              xml.ProductFormDetail("E101")
+            when "Pdf"
+              xml.ProductFormDetail("E107")
+            when "Mobipocket"
+              xml.ProductFormDetail("E127")
+            else
+              xml.ProductFormDetail("E100")
+              xml.ProductFormDescription(product.file_description)
+          end
+
+
+          case product.protection_type
+            when "None"
+              xml.EpubTechnicalProtection("00")
+            when "Drm"
+              xml.EpubTechnicalProtection("01")
+            when "DigitalWatermarking"
+              xml.EpubTechnicalProtection("02")
+            when "AdobeDrm"
+              xml.EpubTechnicalProtection("03")
+          end
+          end
+        end
+
+
+
+        if product.publisher_collection_title
+          xml.Collection {
+            xml.CollectionType("10")
+            xml.TitleDetail {
+              xml.TitleType("01")
+              xml.TitleElement {
+                xml.TitleElementLevel("02")
+                xml.TitleText(product.publisher_collection_title)
+              }
+            }
+          }
+        end
+
+        xml.TitleDetail {
+          xml.TitleType("01")
+          xml.TitleElement {
+            xml.TitleElementLevel("01")
+            xml.TitleText(product.title)
+            if product.subtitle
+              xml.TitleText(product.subtitle)
+            end
+          }
+        }
+
+        product.contributors.each do |c|
+          xml.Contributor {
+            xml.SequenceNumber(c.sequence_number)
+            xml.ContributorRole(c.role.code)
+            xml.PersonName(c.name)
+          }
+        end
+
+        if product.edition_number
+          xml.EditionNumber(product.edition_number)
+        end
+
+        if product.language_of_text
+          xml.Language {
+            xml.LanguageRole("01")
+            xml.LanguageCode(product.language_of_text.code)
+          }
+        end
+
+        product.bisac_categories_codes.each do |s|
+          xml.Subject {
+            xml.SubjectSchemeIdentifier("10")
+            xml.SubjectCode(s)
+          }
+        end
+        product.clil_categories_codes.each do |s|
+          xml.Subject {
+            xml.SubjectSchemeIdentifier("29")
+            xml.SubjectCode(s)
+          }
+        end
+
+        if product.keywords.length > 0
+          xml.Subject {
+            xml.SubjectSchemeIdentifier("20")
+            xml.SubjectHeadingText(product.keywords.join(", "))
+          }
+        end
+
+      }
+      xml.CollateralDetail {
+        xml.TextContent {
+          xml.TextType("03")
+          xml.ContentAudience("00")
+          xml.Text(product.description)
+        }
+
+        # front cover
+        if product.frontcover_url
+        xml.SupportingResource {
+          xml.ResourceContentType("01")
+          xml.ContentAudience("00")
+          xml.ResourceMode("03")
+          xml.ResourceVersion {
+            xml.ResourceForm("02")
+            xml.ResourceLink(product.frontcover_url)
+          }
+        }
+        end
+
+        # sample
+        if product.epub_sample_url
+        xml.SupportingResource {
+          xml.ResourceContentType("15")
+          xml.ContentAudience("00")
+          xml.ResourceMode("04")
+          xml.ResourceVersion {
+            xml.ResourceForm("02")
+              xml.ResourceVersionFeature {
+                xml.ResourceVersionFeatureType("01")
+                xml.FeatureValue("E101")
+              }
+            xml.ResourceLink(product.epub_sample_url)
+          }
+        }
+        end
+
+      }
+      xml.PublishingDetail {
+        if product.imprint
+        xml.Imprint {
+          if product.imprint_gln
+          xml.ImprintIdentifier {
+            xml.ImprintIDType("06")
+            xml.IDValue(product.imprint_gln)
+          }
+          end
+          xml.ImprintName(product.imprint_name)
+        }
+        end
+        if product.publisher_name
+        xml.Publisher {
+          xml.PublishingRole("01")
+          if product.publisher_gln
+          xml.PublisherIdentifier {
+            xml.PublisherIDType("06")
+            xml.IDValue(product.publisher_gln)
+          }
+          end
+          xml.PublisherName(product.publisher_name)
+        }
+        end
+
+        if product.publication_date
+          xml.PublishingDate {
+            xml.PublishingDateRole("01")
+            xml.DateFormat("00")
+            xml.Date(product.publication_date.strftime("%Y%m%d"))
+          }
+        end
+      }
+
+      xml.RelatedMaterial {
+        if product.print_product
+          xml.RelatedProduct {
+            xml.ProductRelationCode("13")
+            xml.ProductIdentifier {
+              xml.ProductIDType("03")
+              xml.IDValue(product.print_product.ean)
+            }
+          }
+        end
+
+        unless product.sold_separately?
+          if product.part_of_product
+            xml.RelatedProduct {
+              xml.ProductRelationCode("02")
+              xml.ProductIdentifier {
+                xml.ProductIDType("03")
+                xml.IDValue(product.part_of_product.ean)
+              }
+            }
+          end
+        end
+
+          }
+
+      if product.sold_separately?
+      product.supplies.each do |supply|
+        xml.ProductSupply {
+          xml.Market {
+            xml.Territory {
+              if ONIX::Territory.worldwide?(supply[:territory])
+                xml.RegionsIncluded("WORLD")
+              else
+                xml.CountriesIncluded(supply[:territory].join(" "))
+              end
+            }
+          }
+          xml.MarketPublishingDetail {
+            if supply[:available]
+              xml.MarketPublishingStatus("04")
+            else
+              xml.MarketPublishingStatus("12")
+            end
+            if supply[:availability_date]
+            xml.MarketDate {
+              xml.MarketDateRole("01")
+              xml.DateFormat("00")
+              xml.Date(supply[:availability_date].strftime("%Y%m%d"))
+            }
+            end
+          }
+
+          xml.SupplyDetail {
+            xml.Supplier {
+              xml.SupplierRole("03")
+              if product.distributor
+
+              if product.distributor_gln
+
+              xml.SupplierIdentifier {
+                xml.SupplierIDType("06")
+                xml.IDValue(product.distributor_gln)
+              }
+              end
+              xml.SupplierName(product.distributor_name)
+              else
+                  xml.SupplierName("Unknown")
+              end
+            }
+
+
+            if supply[:available]
+              xml.ProductAvailability("20")
+            else
+              xml.ProductAvailability("40")
+            end
+
+            supply[:prices].each do |price|
+            xml.Price {
+              if supply[:including_tax]
+                xml.PriceType("04")
+              else
+                xml.PriceType("03")
+
+              end
+              xml.PriceAmount(price[:amount].to_f/100.0)
+              xml.CurrencyCode(supply[:currency])
+
+              if price[:from_date]
+              xml.PriceDate {
+                xml.PriceDateRole("14")
+                xml.Date(price[:from_date].strftime("%Y%m%d"))
+              }
+              end
+              if price[:until_date]
+                xml.PriceDate {
+                  xml.PriceDateRole("15")
+                  xml.Date(price[:until_date].strftime("%Y%m%d"))
+                }
+              end
+            }
+            end
+          }
+
+
+        }
+
+      end
+      else
+        xml.ProductSupply {
+          xml.SupplyDetail {
+            xml.Supplier {
+              xml.SupplierRole("03")
+              if product.distributor
+                if product.distributor_gln
+                  xml.SupplierIdentifier {
+                    xml.SupplierIDType("06")
+                    xml.IDValue(product.distributor_gln)
+                  }
+                end
+                xml.SupplierName(product.distributor_name)
+              else
+                xml.SupplierName("Unknown")
+              end
+
+            }
+            xml.ProductAvailability("45")
+            xml.UnpricedItemType("03")
+          }
+
+        }
+
+          end
+      }
+    end
+  }
+end
+
+puts builder.to_xml
+
+else
+  puts "Onix 3.0 to Onix 3.0 converter"
+  puts "Generate a flattened ONIX 3.0, be aware that conversion could be destructive"
+  puts "Usage: onix3_to_onix3.rb onix.xml"
+end

data/bin/onix_bench.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'im_onix'
+
+filename=ARGV[0]
+
+if filename
+  bench=Benchmark.measure do
+    msg=ONIX::ONIXMessage.new
+    msg.parse(filename)
+  end
+  puts bench
+else
+  puts "ImOnix parse benchmark"
+  puts "Usage: onix_bench.rb file.xml"
+end