cacofonix 0.10.0

data/lib/cacofonix/elements/supply_detail.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+class Cacofonix::SupplyDetail < Cacofonix::Element
+  xml_name "SupplyDetail"
+  xml_accessor :supplier_ean_location_number, :from => "SupplierEANLocationNumber"
+  xml_accessor :supplier_san, :from => "SupplierSAN"
+  onix_composite :supplier_identifiers, Cacofonix::SupplierIdentifier
+  xml_accessor :supplier_name, :from => "SupplierName"
+  xml_accessor :telephone_number, :from => "TelephoneNumber"
+  xml_accessor :fax_number, :from => "FaxNumber"
+  xml_accessor :email_address, :from => "EmailAddress"
+  onix_composite :websites, Cacofonix::Website
+  onix_code_from_list :supplier_role, "SupplierRole", :list => 93
+  onix_spaced_codes_from_list :supply_to_countries, "SupplyToCountry", :list => 91
+  onix_spaced_codes_from_list :supply_to_territories, "SupplyToTerritory", :list => 49
+  onix_spaced_codes_from_list :supply_to_countries_excluded, "SupplyToCountryExcluded", :list => 91
+  xml_accessor :supply_restriction_detail, :from => "SupplyRestrictionDetail"
+  onix_code_from_list :returns_code_type, "ReturnsCodeType", :list => 53
+  xml_accessor :returns_code, :from => "ReturnsCode"
+  onix_date_accessor :last_date_for_returns, "LastDateForReturns"
+  onix_code_from_list :availability_code, "AvailabilityCode", :list => 54
+  alias_accessor :availability_status_code, :availability_code # back-compat
+  onix_code_from_list :product_availability, "ProductAvailability", :list => 65
+  onix_composite :new_supplier, Cacofonix::NewSupplier, :singular => true
+  onix_code_from_list :date_format, "DateFormat", :list => 55
+  xml_accessor :expected_ship_date, :from => "ExpectedShipDate"
+  onix_date_accessor :on_sale_date, "OnSaleDate"
+  xml_accessor :order_time, :from => "OrderTime", :as => Integer
+  onix_composite :stocks, Cacofonix::Stock
+  alias_accessor :stock, :stocks # back-compat
+  xml_accessor :pack_quantity, :from => "PackQuantity", :as => Integer
+  onix_code_from_list :audience_restriction_flag, "AudienceRestrictionFlag", :list => 56
+  xml_accessor :audience_restriction_note, :from => "AudienceRestrictionNote"
+  onix_code_from_list :unpriced_item_type, "UnpricedItemType", :list => 57
+  onix_composite :prices, Cacofonix::Price
+  onix_composite :reissue, Cacofonix::Reissue, :singular => true
+end

data/lib/cacofonix/elements/text_item.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+class Cacofonix::TextItem < Cacofonix::Element
+  xml_name "TextItem"
+  onix_code_from_list :text_item_type, "TextItemType", :list => 42
+  onix_composite :text_item_identifier, Cacofonix::TextItemIdentifier
+  xml_accessor :first_page_number, :from => "FirstPageNumber"
+  xml_accessor :last_page_number, :from => "LastPageNumber"
+  onix_composite :page_runs, Cacofonix::PageRun
+  xml_accessor :number_of_pages, :from => "NumberOfPages", :as => Integer
+end

data/lib/cacofonix/elements/text_item_identifier.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+class Cacofonix::TextItemIdentifier < Cacofonix::Identifier
+  xml_name "TextItemIdentifier"
+  onix_code_from_list :text_item_identifier, "TextItemIdentifier", :list => 43
+end

data/lib/cacofonix/elements/title.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+class Cacofonix::Title < Cacofonix::Element
+  xml_name "Title"
+  onix_code_from_list :title_type, "TitleType", :list => 15
+  xml_accessor :abbreviated_length, :from => "AbbreviatedLength", :as => Integer
+  xml_accessor :title_text, :from => "TitleText"
+  xml_accessor :title_prefix, :from => "TitlePrefix"
+  xml_accessor :title_without_prefix, :from => "TitleWithoutPrefix"
+  xml_accessor :subtitle,   :from => "Subtitle"
+end

data/lib/cacofonix/elements/website.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+class Cacofonix::Website < Cacofonix::Element
+  xml_name "Website"
+  onix_code_from_list :website_role, "WebsiteRole", :list => 73
+  xml_accessor :website_description, :from => "WebsiteDescription"
+  xml_accessor :website_link, :from => "WebsiteLink"
+end

data/lib/cacofonix/elements/work_identifier.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+class Cacofonix::WorkIdentifier < Cacofonix::Identifier
+  xml_name "WorkIdentifier"
+  onix_code_from_list :work_id_type, "WorkIDType", :list => 16
+end

data/lib/cacofonix/utils/code_list_extractor.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+module Cacofonix
+
+  # A utility class that processes the code list XSD from the ONIX spec and
+  # creates a set of TSV files. The generated files are used by this library
+  # to make hashes of the code lists available to users.
+  #
+  class CodeListExtractor
+
+    FORMATS = [:tsv, :ruby]
+
+    # Creates a new extractor. Expects the path to a copy of the code lists
+    # file from the spec (called ONIX_BookProduct_CodeLists.xsd on my system).
+    #
+    def initialize(filename, format = :tsv)
+      raise ArgumentError, "#{filename} not found" unless File.file?(filename)
+
+      @filename = filename
+      raise "Unknown format: #{format}"  unless FORMATS.include?(format)
+      @format = format
+    end
+
+    # Generate one file for each list in the specified format in the given
+    # directory. Creates the directory if it doesn't exist. This will
+    # overwrite any existing files.
+    #
+    def run(dir)
+      FileUtils.mkdir_p(dir)
+
+      each_list do |number, data|
+        send("write_to_#{@format}_format", dir, number, data)
+      end
+    end
+
+
+    private
+
+    def data
+      @data ||= File.open(@filename) { |f| f.read }
+    end
+
+    def document
+      @document ||= Nokogiri::XML(data)
+      @document.remove_namespaces! if @document.namespaces.size > 0
+      @document
+    end
+
+    def each_list(&block)
+      document.xpath("//simpleType").each do |node|
+        list_name   = node.xpath("./@name").first.value
+        list_number = list_name[/List(\d+)/,1].to_i
+        if list_number > 0
+          yield list_number, list_data(list_number)
+        end
+      end
+    end
+
+    def list_data(num)
+      nodes = document.xpath("//simpleType[@name='List#{num}']/restriction/enumeration")
+      nodes.inject([]) do |arr, node|
+        code  = node.xpath("./@value").first.value
+        desc  = node.xpath("./annotation/documentation").first.text
+        ldesc = node.xpath("./annotation/documentation").last.text
+        arr.tap { |a| a << [code, desc, ldesc] }
+      end
+    end
+
+    def write_to_tsv_format(dir, number, data)
+      file = number.to_s.rjust(3, "0") + ".tsv"
+      path = File.join(dir, file)
+      out = data.collect { |row| row.join("\t") }.join("\n")
+      File.open(path, "w") { |f| f.write out }
+    end
+
+    def write_to_ruby_format(dir, number, data)
+      list_num = number.to_s.rjust(3, "0")
+      file = list_num + ".rb"
+      path = File.join(dir, file)
+      str2str = lambda { |str|
+        str.gsub!("\342\200\230", "'")
+        str.gsub!("\342\200\231", "'")
+        str.gsub!("\342\200\234", '"')
+        str.gsub!("\342\200\235", '"')
+        str.gsub!(/"/, '\"')
+        "\"#{str}\""
+      }
+      # An alternative format: two-dimensional array. More complete,
+      # but less addressable.
+      #
+      # out = ["# coding: utf-8"]
+      # out << "module Cacofonix; module CodeLists"
+      # out << "  LIST_#{number} = ["
+      # out += data.collect { |row|
+      #   row = row.collect { |f| "      #{str2str.call(f)}" }
+      #   "    [\n#{row.join(",\n")}\n    ]"
+      # }.join(",\n")
+      # out << "  ]"
+      # out << "end; end"
+      out = ["# coding: utf-8\n"]
+      out << "module Cacofonix; module CodeLists"
+      out << "  LIST_#{number} = {"
+      out << data.collect { |row|
+        "    #{str2str.call(row[0])} => #{str2str.call(row[1])}"
+      }.join(",\n")
+      out << "  }"
+      out << "end; end"
+      File.open(path, "w") { |f| f.write out.join("\n") }
+    end
+
+  end
+end

data/lib/cacofonix/utils/normaliser.rb

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+require 'tempfile'
+require 'fileutils'
+
+module Cacofonix
+
+  # A standalone class that can be used to normalise ONIX files
+  # into a standardised form. If you're accepting ONIX files from a wide range
+  # of suppliers, you're guarunteed to get all sorts of dialects.
+  #
+  # This will create a new file that:
+  #
+  # - is UTF-8 encoded
+  # - uses reference tags, not short
+  # - has no named entities (ndash, etc) other than & < and >
+  #
+  # Usage:
+  #
+  #   Cacofonix::Normaliser.process("oldfile.xml", "newfile.xml")
+  #
+  # Dependencies:
+  #
+  # At this stage the class depends on several external apps, all commonly available
+  # on *nix systems: xsltproc, isutf8, iconv and sed
+  #
+  class Normaliser
+
+    class << self
+
+      # normalise oldfile and save it as newfile. oldfile
+      # will be left untouched
+      #
+      def process(oldfile, newfile)
+        self.new(oldfile).normalise_to_path(newfile)
+      end
+    end
+
+    # NB: Newfile argument is deprecated.
+    #
+    def initialize(oldfile, newfile = nil)
+      raise ArgumentError, "#{oldfile} does not exist" unless File.file?(oldfile)
+      raise "xsltproc app not found" unless app_available?("xsltproc")
+      raise "tr app not found"       unless app_available?("tr")
+
+      @oldfile = oldfile
+      @newfile = newfile
+      @curfile = next_tempfile
+      FileUtils.cp(@oldfile, @curfile)
+      @head    = File.open(@oldfile, "r") { |f| f.read(1024) }
+    end
+
+    # This is deprecated - use normalise_to_path with a path.
+    def run
+      normalise_to_path(@newfile)
+    end
+
+    def normalise_to_path(newfile)
+      raise ArgumentError, "#{newfile} already exists" if File.file?(newfile)
+      @curfile = normalise_to_tempfile
+      FileUtils.cp(@curfile, newfile)
+    end
+
+    # Processes oldfile and puts the normalised result in a tempfile,
+    # returning the path to that tempfile.
+    #
+    def normalise_to_tempfile
+      src = @curfile
+
+      # remove short tags
+      if @head.include?("ONIXmessage")
+        dest = next_tempfile
+        to_reference_tags(src, dest)
+        src = dest
+      end
+
+      # remove control chars
+      dest = next_tempfile
+      remove_control_chars(src, dest)
+      dest
+    end
+
+    #private
+
+    # check the specified app is available on the system
+    #
+    def app_available?(app)
+      `which #{app}`.strip == "" ? false : true
+    end
+
+    # generate a temp filename
+    #
+    def next_tempfile
+      p = nil
+      Tempfile.open("onix") do |tf|
+        p = tf.path
+        tf.close!
+      end
+      p
+    end
+
+    # uses an XSLT stylesheet provided by edituer to convert
+    # a file from short tags to long tags.
+    #
+    # more detail here:
+    #   http://www.editeur.org/files/ONIX%203/ONIX%20tagname%20converter%20v2.htm
+    #
+    def to_reference_tags(src, dest)
+      inpath = File.expand_path(src)
+      outpath = File.expand_path(dest)
+      xsltpath = File.dirname(__FILE__) + "/../../../support/switch-onix-2.1-short-to-reference.xsl"
+      `xsltproc -o #{outpath} #{xsltpath} #{inpath}`
+    end
+
+    # XML files shouldn't contain low ASCII control chars. Strip them.
+    #
+    def remove_control_chars(src, dest)
+      inpath = File.expand_path(src)
+      outpath = File.expand_path(dest)
+      `cat #{inpath} | tr -d "\\000-\\010\\013\\014\\016-\\037" > #{outpath}`
+    end
+
+  end
+
+end

data/lib/cacofonix/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cacofonix
+  VERSION = "0.10.0"
+end

data/lib/cacofonix/wrappers/apa_product.rb

@@ -0,0 +1,748 @@
+# coding: utf-8
+
+module Cacofonix
+  class APAProduct < SimpleProduct
+
+    delegate :record_reference, :record_reference=
+    delegate :notification_type, :notification_type=
+    delegate :product_form, :product_form=
+    delegate :edition, :edition=
+    delegate :number_of_pages, :number_of_pages=
+    delegate :bic_main_subject, :bic_main_subject=
+    delegate :publishing_status, :publishing_status=
+    delegate :publication_date, :publication_date=
+
+    def measurement_system
+      @measurement_system ||= :metric
+    end
+
+    def measurement_system=(value)
+      if value == :metric || value == :imperial
+        @measurement_system = value
+      else
+        raise ArgumentError, "#{value} is not a recognised measurement system"
+      end
+    end
+
+    # retrieve the current EAN
+    def ean
+      identifier(3).try(:id_value)
+    end
+
+    # set a new EAN
+    def ean=(isbn)
+      identifier_set(3, isbn)
+    end
+
+    # retrieve the proprietary ID
+    def proprietary_id
+      identifier(1).tr(:id_value)
+    end
+
+    # set a new proprietary ID
+    def proprietary_id=(isbn)
+      identifier_set(1, isbn)
+    end
+
+    # retrieve the current ISBN 10
+    def isbn10
+      identifier(2).try(:id_value)
+    end
+
+    # set a new ISBN 10
+    def isbn10=(isbn)
+      identifier_set(2, isbn)
+    end
+
+    # retrieve the current ISBN 13
+    def isbn13
+      identifier(15).try(:id_value)
+    end
+
+    # set a new ISBN 13
+    def isbn13=(isbn)
+      identifier_set(15, isbn)
+    end
+
+    # retrieve the current title
+    def title
+      composite = product.titles.first
+      if composite.nil?
+        nil
+      else
+        composite.title_text || composite.title_without_prefix
+      end
+    end
+
+    # set a new title
+    def title=(str)
+      composite = product.titles.first
+      if composite.nil?
+        composite =  Cacofonix::Title.new
+        composite.title_type = 1
+        product.titles << composite
+      end
+      composite.title_text = str
+    end
+
+    # retrieve the current subtitle
+    def subtitle
+      composite = product.titles.first
+      if composite.nil?
+        nil
+      else
+        composite.subtitle
+      end
+    end
+
+    # set a new subtitle
+    def subtitle=(str)
+      composite = product.titles.first
+      if composite.nil?
+        composite =  Cacofonix::Title.new
+        composite.title_type = 1
+        product.titles << composite
+      end
+      composite.subtitle = str
+    end
+
+    def series
+      composite = product.series.first
+      composite.try(:title_of_series)
+    end
+
+    def series=(val)
+      composite = product.series.first
+      if composite.nil?
+        composite =  Cacofonix::Series.new
+        product.series << composite
+      end
+      composite.title_of_series = val.to_s
+    end
+
+    # retrieve the current publisher website for this particular product
+    def publisher_website
+      website(2).try(:website_link)
+    end
+
+    # set a new publisher website for this particular product
+    def publisher_website=(str)
+      website_set(2, str)
+    end
+
+    # retrieve the current supplier website for this particular product
+    def supplier_website
+      website(12).try(:website_link)
+    end
+
+    # set a new supplier website for this particular product
+    def supplier_website=(str)
+      website_set(12, str)
+    end
+
+    # retrieve an array of all contributors
+    def contributors
+      product.contributors.collect { |contrib| contrib.person_name_inverted || contrib.person_name}
+    end
+
+    # set a new contributor to this product
+    # str should be the contributors name inverted (Healy, James)
+    def add_contributor(str, role = "A01")
+      contrib = ::Cacofonix::Contributor.new
+      contrib.sequence_number = product.contributors.size + 1
+      contrib.contributor_role = role
+      contrib.person_name_inverted = str
+      product.contributors << contrib
+    end
+
+    # return an array of BIC subjects for this title
+    # could be version 1 or version 2, most ONIX files don't
+    # specifiy
+    def bic_subjects
+      subjects = product.subjects.select { |sub| sub.subject_scheme_id.to_i == 12 }
+      subjects.collect { |sub| sub.subject_code}
+    end
+
+    # add a BIC subject code to the product
+    def add_bic_subject(code)
+      add_subject code, "12"
+    end
+
+    # return an array of BISAC subjects for this title
+    def bisac_subjects
+      subjects = product.subjects.select { |sub| sub.subject_scheme_id.to_i == 10 }
+      subjects.collect { |sub| sub.subject_code}
+    end
+
+    # add a BISAC subject code to the product
+    def add_bisac_subject(code)
+      add_subject code, "10"
+    end
+
+    # retrieve the url to the product cover image
+    def cover_url
+      media_file(4).try(:media_file_link)
+    end
+
+    # set the url to the product cover image
+    def cover_url=(url)
+      # 4 - cover image
+      # 1 - URI
+      media_file_set(4,1,url)
+    end
+
+    # retrieve the url to the high quality product cover image
+    def cover_url_hq
+      media_file(6).try(:media_file_link)
+    end
+
+    # set the url to the high quality product cover image
+    def cover_url_hq=(url)
+      # 6 - hq cover image
+      # 1 - URI
+      media_file_set(6,1,url)
+    end
+
+    # retrieve the url to the product thumbnail
+    def thumbnail_url
+      media_file(7).try(:media_file_link)
+    end
+
+    # set the url to the product cover image
+    def thumbnail_url=(url)
+      # 7 - thumbnail image
+      # 1 - URI
+      media_file_set(7,1,url)
+    end
+
+    # retrieve the main description
+    def main_description
+      other_text(1).try(:text)
+    end
+
+    # set the main description
+    def main_description=(t)
+      other_text_set(1,t)
+    end
+
+    # retrieve the short description
+    def short_description
+      other_text(2).try(:text)
+    end
+
+    # set the short description
+    def short_description=(t)
+      other_text_set(2,t)
+    end
+
+    # retrieve the long description
+    def long_description
+      other_text(3).try(:text)
+    end
+
+    # set the long description
+    def long_description=(t)
+      other_text_set(3,t)
+    end
+
+    # retrieve the imprint
+    def imprint
+      composite = product.imprints.first
+      composite ? composite.imprint_name : nil
+    end
+
+    # set a new imprint
+    def imprint=(str)
+      composite = product.imprints.first
+      if composite.nil?
+        composite =  Cacofonix::Imprint.new
+        product.imprints << composite
+      end
+      composite.imprint_name = str
+    end
+
+    # retrieve the publisher
+    def publisher
+      publisher_get(1).try(:publisher_name)
+    end
+
+    # set a new publisher
+    def publisher=(str)
+      publisher_set(1, str)
+    end
+
+    # retrieve the sales restriction type
+    def sales_restriction_type
+      composite = product.sales_restrictions.first
+      composite.nil? ? nil : composite.imprint_name
+    end
+
+    # set a new sales restriction type
+    def sales_restriction_type=(type)
+      composite = product.sales_restrictions.first
+      if composite.nil?
+        composite =  Cacofonix::SalesRestriction.new
+        product.sales_restrictions << composite
+      end
+      composite.sales_restriction_type = type
+    end
+
+    # retrieve the supplier name
+    def supplier_name
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.supplier_name
+    end
+
+    # set a new supplier name
+    def supplier_name=(str)
+      composite = find_or_create_supply_detail
+      composite.supplier_name = str
+    end
+
+    # retrieve the supplier phone number
+    def supplier_phone
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.telephone_number
+    end
+
+    # set a new supplier phone number
+    def supplier_phone=(str)
+      composite = find_or_create_supply_detail
+      composite.telephone_number = str
+    end
+
+    # retrieve the supplier fax number
+    def supplier_fax
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.fax_number
+    end
+
+    # set a new supplier fax number
+    def supplier_fax=(str)
+      composite = find_or_create_supply_detail
+      composite.fax_number = str
+    end
+
+    # retrieve the supplier email address
+    def supplier_email
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.email_address
+    end
+
+    # set a new supplier email address
+    def supplier_email=(str)
+      composite = find_or_create_supply_detail
+      composite.email_address = str
+    end
+
+    # retrieve the supply country code
+    def supply_country
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.supply_to_country
+    end
+
+    # set a new supply country code
+    def supply_country=(str)
+      composite = find_or_create_supply_detail
+      composite.supply_to_country = str
+    end
+
+    # retrieve the product availability code
+    def product_availability
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.product_availability
+    end
+
+    # set a new product availability
+    def product_availability=(num)
+      composite = find_or_create_supply_detail
+      composite.product_availability = num
+    end
+
+    # retrieve the number in stock
+    def on_hand
+      supply = find_or_create_supply_detail
+      composite = supply.stock.first
+      if composite.nil?
+        composite = Cacofonix::Stock.new
+        supply.stock << composite
+      end
+      composite.on_hand
+    end
+
+    # set a new in stock quantity
+    def on_hand=(num)
+      supply = find_or_create_supply_detail
+      composite = supply.stock.first
+      if composite.nil?
+        composite = Cacofonix::Stock.new
+        supply.stock << composite
+      end
+      composite.on_hand = num
+    end
+
+    # retrieve the number on order
+    def on_order
+      supply = find_or_create_supply_detail
+      composite = supply.stock.first
+      if composite.nil?
+        composite = Cacofonix::Stock.new
+        supply.stock << composite
+      end
+      composite.on_order
+    end
+
+    # set a new on order quantity
+    def on_order=(num)
+      supply = find_or_create_supply_detail
+      composite = supply.stock.first
+      if composite.nil?
+        composite = Cacofonix::Stock.new
+        supply.stock << composite
+      end
+      composite.on_order = num
+    end
+
+    # retrieve the supplier phone number
+    def pack_quantity
+      composite = product.supply_details.first
+      composite.nil? ? nil : composite.pack_quantity
+    end
+
+    # set a new supplier phone number
+    def pack_quantity=(val)
+      composite = find_or_create_supply_detail
+      composite.pack_quantity = val.to_i
+    end
+
+    # retrieve the rrp excluding any sales tax
+    def rrp_exc_sales_tax
+      price_get(1).try(:price_amount)
+    end
+
+    # set the rrp excluding any sales tax
+    def rrp_exc_sales_tax=(num)
+      price_set(1, num)
+    end
+
+    # retrieve the rrp including any sales tax
+    def rrp_inc_sales_tax
+      price_get(2).try(:price_amount)
+    end
+
+    # set the rrp including any sales tax
+    def rrp_inc_sales_tax=(num)
+      price_set(2, num)
+    end
+
+    # just get the first price we can find, regardless of the type.
+    # useful as a backup for reading files from that don't contain a type
+    def price
+      price_get(nil).try(:price_amount)
+    end
+
+    # retrieve the height of the product
+    #
+    # If APAProduct#measurement_system is metric, these will be in mm, otherwise they
+    # will be in inches.
+    #
+    def height
+      # TODO: auto unit conversion
+      measurement(1).try(:measurement)
+    end
+
+    # set the height of the book
+    #
+    # If APAProduct#measurement_system is metric, this should be in mm, otherwise it
+    # will be in inches.
+    #
+    def height=(value)
+      if measurement_system == :metric
+        measurement_set(1,value, "mm")
+      elsif measurement_system == :imperial
+        measurement_set(1,value, "in")
+      end
+    end
+
+    # retrieve the width of the product
+    #
+    # If APAProduct#measurement_system is metric, these will be in mm, otherwise they
+    # will be in inches.
+    #
+    def width
+      # TODO: auto unit conversion
+      measurement(2).try(:measurement)
+    end
+
+    # set the width of the product
+    #
+    # If APAProduct#measurement_system is metric, this should be in mm, otherwise it
+    # will be in inches.
+    #
+    def width=(value)
+      if measurement_system == :metric
+        measurement_set(2,value, "mm")
+      elsif measurement_system == :imperial
+        measurement_set(2,value, "in")
+      end
+    end
+
+    # retrieve the weight of the product
+    #
+    # If APAProduct#measurement_system is metric, these will be in grams, otherwise they
+    # will be in ounces.
+    #
+    def weight
+      # TODO: auto unit conversion
+      measurement(8).try(:measurement)
+    end
+
+    # set the weight of the product
+    #
+    # If APAProduct#measurement_system is metric, this should be in grams, otherwise it
+    # will be in ounces.
+    #
+    def weight=(value)
+      if measurement_system == :metric
+        measurement_set(8,value, "gr")
+      elsif measurement_system == :imperial
+        measurement_set(8,value, "oz")
+      end
+    end
+
+    # retrieve the thickness of the product
+    #
+    # If APAProduct#measurement_system is metric, these will be in mm, otherwise they
+    # will be in inches.
+    #
+    def thickness
+      # TODO: auto unit conversion
+      measurement(3).try(:measurement)
+    end
+
+    # set the thickness of the product
+    #
+    # If APAProduct#measurement_system is metric, this should be in mm, otherwise it
+    # will be in inches.
+    #
+    def thickness=(value)
+      if measurement_system == :metric
+        measurement_set(3,value, "mm")
+      elsif measurement_system == :imperial
+        measurement_set(3,value, "in")
+      end
+    end
+
+    def agent_name
+      reps = product.market_representations.first
+      return nil if reps.nil?
+      reps.agent_name
+    end
+
+    def agent_name=(value)
+      reps = product.market_representations.first
+      if reps.nil?
+        reps = Cacofonix::MarketRepresentation.new
+        product.market_representations << reps
+      end
+      reps.agent_name = value.to_s
+    end
+
+    def market_country
+      reps = product.market_representations.first
+      return nil if reps.nil?
+      reps.market_country
+    end
+
+    def market_country=(value)
+      reps = product.market_representations.first
+      if reps.nil?
+        reps = Cacofonix::MarketRepresentation.new
+        product.market_representations << reps
+      end
+      reps.market_country = value.to_s
+    end
+
+    def market_publishing_status
+      reps = product.market_representations.first
+      return nil if reps.nil?
+      reps.market_publishing_status
+    end
+
+    def market_publishing_status=(value)
+      reps = product.market_representations.first
+      if reps.nil?
+        reps = Cacofonix::MarketRepresentation.new
+        product.market_representations << reps
+      end
+      reps.market_publishing_status = value.to_i
+    end
+
+    private
+
+    # add a new subject to this product
+    # str should be the subject code
+    # type should be the code for the subject scheme you're using. See ONIX codelist 27.
+    # 12 is BIC
+    def add_subject(str, type = "12")
+      subject = ::Cacofonix::Subject.new
+      subject.subject_scheme_id = type.to_i
+      subject.subject_code = str
+      product.subjects << subject
+    end
+
+    def find_or_create_supply_detail
+      composite = product.supply_details.first
+      if composite.nil?
+        composite =  Cacofonix::SupplyDetail.new
+        product.supply_details << composite
+      end
+      composite
+    end
+
+    # retrieve the value of a particular ID
+    def identifier(type)
+      product.product_identifiers.find { |id| id.product_id_type == type }
+    end
+
+    # set the value of a particular ID
+    def identifier_set(type, value)
+      isbn_id = identifier(type)
+
+      # create a new isbn record if we need to
+      if isbn_id.nil?
+        isbn_id = Cacofonix::ProductIdentifier.new
+        isbn_id.product_id_type = type
+        product.product_identifiers << isbn_id
+      end
+
+      isbn_id.id_value = value
+    end
+
+    # retrieve the value of a particular measurement
+    def measurement(type)
+      product.measurements.find { |m| m.measure_type_code == type }
+    end
+
+    # set the value of a particular measurement
+    def measurement_set(type, value, unit)
+      measure = measurement(type)
+
+      # create a new isbn record if we need to
+      if measure.nil?
+        measure = Cacofonix::Measure.new
+        measure.measure_type_code = type
+        product.measurements << measure
+      end
+
+      # store the new value
+      measure.measurement = value
+      measure.measure_unit_code = unit.to_s
+    end
+
+    # retrieve the value of a particular media file
+    def media_file(type)
+      product.media_files.find { |m| m.media_file_type_code == type }
+    end
+
+    # set the value of a particular ID
+    def media_file_set(type, link_type, value)
+      media = media_file(type)
+
+      # create a new isbn record if we need to
+      if media.nil?
+        media = Cacofonix::MediaFile.new
+        media.media_file_type_code = type
+        media.media_file_link_type_code = link_type
+        product.media_files << media
+      end
+
+      # store the new value
+      media.media_file_link = value.to_s
+    end
+
+    # retrieve the value of a particular price
+    def price_get(type)
+      supply = find_or_create_supply_detail
+      if type.nil?
+        supply.prices.first
+      else
+        supply.prices.find { |p| p.price_type_code == type }
+      end
+    end
+
+    # set the value of a particular price
+    def price_set(type, num)
+      p = price_get(type)
+
+      # create a new isbn record if we need to
+      if p.nil?
+        supply = find_or_create_supply_detail
+        p = Cacofonix::Price.new
+        p.price_type_code = type
+        supply.prices << p
+      end
+
+      # store the new value
+      p.price_amount = num
+    end
+
+    # retrieve the value of a particular publisher
+    def publisher_get(type)
+      product.publishers.find { |pub| pub.publishing_role == type }
+    end
+
+    # set the value of a particular ID
+    def publisher_set(type, value)
+      pub = publisher_get(type)
+
+      # create a new isbn record if we need to
+      if pub.nil?
+        pub = Cacofonix::Publisher.new
+        pub.publishing_role = type
+        product.publishers << pub
+      end
+
+      # store the new value
+      pub.publisher_name = value.to_s
+    end
+
+    # retrieve the value of a particular other text value
+    def other_text(type)
+      product.text.find { |t| t.text_type_code == type }
+    end
+
+    # set the value of a particular other text value
+    def other_text_set(type, value)
+      text = other_text(type)
+
+      if text.nil?
+        text = Cacofonix::OtherText.new
+        text.text_type_code = type
+        product.text << text
+      end
+
+      # store the new value
+      text.text = value.to_s
+    end
+
+    # retrieve the value of a particular website
+    def website(type)
+      product.websites.find { |site| site.website_role == type }
+    end
+
+    # set the value of a particular website
+    def website_set(type, value)
+      site = website(type)
+
+      # create a new website record if we need to
+      if site.nil?
+        site = Cacofonix::Website.new
+        site.website_role = type
+        product.websites << site
+      end
+
+      site.website_link = value.to_s
+    end
+  end
+end