cacofonix 0.10.0

data/lib/cacofonix/codelists/170.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_170 = {
+
+  }
+end; end

data/lib/cacofonix/codelists/171.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_171 = {
+    "01" => "VAT",
+    "02" => "GST"
+  }
+end; end

data/lib/cacofonix/codelists/172.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_172 = {
+    "EUR" => "Eurozone"
+  }
+end; end

data/lib/cacofonix/codelists/173.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_173 = {
+    "14" => "From date",
+    "15" => "Until date"
+  }
+end; end

data/lib/cacofonix/codelists/174.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_174 = {
+    "01" => "No",
+    "02" => "Yes"
+  }
+end; end

data/lib/cacofonix/codelists/175.rb

@@ -0,0 +1,206 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_175 = {
+    "A101" => "CD standard audio format",
+    "A102" => "SACD super audio format",
+    "A103" => "MP3 format",
+    "A104" => "WAV format",
+    "A105" => "Real Audio format",
+    "A106" => "WMA",
+    "A107" => "AAC",
+    "A108" => "Ogg/Vorbis",
+    "A109" => "Audible",
+    "A110" => "FLAC",
+    "A111" => "AIFF",
+    "A112" => "ALAC",
+    "A201" => "DAISY 2: full audio with title only (no navigation)",
+    "A202" => "DAISY 2: full audio with navigation (no text)",
+    "A203" => "DAISY 2: full audio with navigation and partial text",
+    "A204" => "DAISY 2: full audio with navigation and full text",
+    "A205" => "DAISY 2: full text with navigatino and partial audio",
+    "A206" => "DAISY 2: full text with navigation and no audio",
+    "A207" => "DAISY 3: full audio with title only (no navigation)",
+    "A208" => "DAISY 3: full audio with navigation (no text)",
+    "A209" => "DAISY 3: full audio with navigation and partial text",
+    "A210" => "DAISY 3: full audio with navigation and full text",
+    "A211" => "DAISY 3: full textwith navigation and partial audio",
+    "A212" => "DAISY 3: full text with navigation and no audio",
+    "B101" => "Mass market (rack) paperback",
+    "B102" => "Trade paperback (US)",
+    "B103" => "Digest format paperback",
+    "B104" => "A-format paperback",
+    "B105" => "B-format paperback",
+    "B106" => "Trade paperback (UK)",
+    "B107" => "Tall rack paperback (US)",
+    "B108" => "A5: Tankobon",
+    "B109" => "B5: Tankobon",
+    "B110" => "B6: Tankobon",
+    "B111" => "A6: Bunko",
+    "B112" => "B40-dori: Shinsho",
+    "B113" => "Pocket (Sweden)",
+    "B114" => "Storpocket (Sweden)",
+    "B115" => "Kartonnage (Sweden)",
+    "B116" => "Flexband (Sweden)",
+    "B117" => "Mook",
+    "B118" => "Dwarsligger",
+    "B119" => "46 size",
+    "B120" => "46-Henkei size",
+    "B121" => "A4",
+    "B122" => "A4-Henkei size",
+    "B123" => "A5-Henkei size",
+    "B124" => "B5-Henkei size",
+    "B125" => "B6-Henkei size",
+    "B126" => "AB size",
+    "B127" => "B7 size",
+    "B128" => "Kiku size",
+    "B129" => "Kiku-Henkei size",
+    "B201" => "Coloring / join-the-dot book",
+    "B202" => "Lift-the-flap book",
+    "B204" => "Miniature book",
+    "B205" => "Moving picture / flicker book",
+    "B206" => "Pop-up book",
+    "B207" => "Scented / 'smelly' book",
+    "B208" => "Sound story / 'noisy' book",
+    "B209" => "Sticker book",
+    "B210" => "Touch-and-feel book",
+    "B212" => "Die-cut book",
+    "B213" => "Book-as-toy",
+    "B214" => "Soft-to-touch book",
+    "B215" => "Fuzzy-felt book",
+    "B221" => "Picture book",
+    "B222" => "'Carousel' Book",
+    "B301" => "Loose leaf - sheets and binder",
+    "B302" => "Loose leaf - binder only",
+    "B303" => "Loose leaf - sheets only",
+    "B304" => "Sewn",
+    "B305" => "Unsewn / adhesive bound",
+    "B306" => "Library binding",
+    "B307" => "Reinforced binding",
+    "B308" => "Half bound",
+    "B309" => "Quarter bound",
+    "B310" => "Saddle-sewn",
+    "B311" => "Comb bound",
+    "B312" => "Wire-O",
+    "B313" => "Concealed wire",
+    "B401" => "Cloth over boards",
+    "B402" => "Paper over boards",
+    "B403" => "Leather, real",
+    "B404" => "Leather, imitation",
+    "B405" => "Leather, bonded",
+    "B406" => "Vellum",
+    "B409" => "Cloth",
+    "B410" => "Imitation cloth",
+    "B411" => "Velvet",
+    "B412" => "Flexible plastic/vinyl cover",
+    "B413" => "Plastic-covered",
+    "B414" => "Vinyl-covered",
+    "B415" => "Laminated cover",
+    "B501" => "With dust jacket",
+    "B502" => "With printed dust jacket",
+    "B503" => "With translucent dust cover",
+    "B504" => "With flaps",
+    "B505" => "With thumb index",
+    "B506" => "With ribbon marker(s)",
+    "B507" => "With zip fastener",
+    "B508" => "With button snap fastener",
+    "B509" => "With leather edge lining",
+    "B510" => "Rough front",
+    "B601" => "Turn-around book",
+    "B602" => "Unflipped manga format",
+    "B701" => "UK Uncontracted Braille",
+    "B702" => "UK Contracted Braille",
+    "B703" => "US Braille",
+    "B704" => "US Uncontracted Braille",
+    "B705" => "US Contracted Braille",
+    "B706" => "Unified English Braille",
+    "B707" => "Moon",
+    "D101" => "Real Video format",
+    "D102" => "Quicktime format",
+    "D103" => "AVI format",
+    "D104" => "Windows Media Video format",
+    "D105" => "MPEG-4",
+    "D201" => "MS-DOS",
+    "D202" => "Windows",
+    "D203" => "Macintosh",
+    "D204" => "UNIX / LINUX",
+    "D205" => "Other operating system(s)",
+    "D206" => "Palm OS",
+    "D207" => "Windows Mobile",
+    "D301" => "Microsoft XBox",
+    "D302" => "Nintendo Gameboy Color",
+    "D303" => "Nintendo Gameboy Advanced",
+    "D304" => "Nintendo Gameboy",
+    "D305" => "Nintendo Gamecube",
+    "D306" => "Nintendo 64",
+    "D307" => "Sega Dreamcast",
+    "D308" => "Sega Genesis/Megadrive",
+    "D309" => "Sega Saturn",
+    "D310" => "Sony PlayStation 1",
+    "D311" => "Sony PlayStation 2",
+    "D312" => "Nintendo Dual Screen",
+    "D313" => "Sony PlayStation 3",
+    "D314" => "Xbox 360",
+    "D315" => "Nintendo Wii",
+    "D316" => "Sony PlayStation Portable (PSP)",
+    "E100" => "Other",
+    "E101" => "EPUB",
+    "E102" => "OEB",
+    "E103" => "DOC",
+    "E104" => "DOCX",
+    "E105" => "HTML",
+    "E106" => "ODF",
+    "E107" => "PDF",
+    "E108" => "PDF/A",
+    "E109" => "RTF",
+    "E110" => "SGML",
+    "E111" => "TCR",
+    "E112" => "TXT",
+    "E113" => "XHTML",
+    "E114" => "zTXT",
+    "E115" => "XPS",
+    "E116" => "Amazon Kindle",
+    "E117" => "BBeB",
+    "E118" => "DXReader",
+    "E119" => "EBL",
+    "E120" => "Ebrary",
+    "E121" => "eReader",
+    "E122" => "Exebook",
+    "E123" => "Franklin eBookman",
+    "E124" => "Gemstar Rocketbook",
+    "E125" => "iSilo",
+    "E126" => "Microsoft Reader",
+    "E127" => "Mobipocket",
+    "E128" => "MyiLibrary",
+    "E129" => "NetLibrary",
+    "E130" => "Plucker",
+    "E131" => "VitalBook",
+    "E132" => "Vook",
+    "E133" => "Google Edition",
+    "E134" => "Book 'app' for iOS",
+    "E135" => "Book 'app' for Android",
+    "E136" => "Book 'app' for other operating system",
+    "L101" => "Laminated",
+    "P101" => "Desk calendar",
+    "P102" => "Mini calendar",
+    "P103" => "Engagement calendar",
+    "P104" => "Day by day calendar",
+    "P105" => "Poster calendar",
+    "P106" => "Wall calendar",
+    "P107" => "Perpetual calendar",
+    "P108" => "Advent calendar",
+    "P109" => "Bookmark calendar",
+    "P110" => "Student calendar",
+    "P111" => "Project calendar",
+    "P112" => "Almanac calendar",
+    "P113" => "Other calendar",
+    "P114" => "Other calendar or organiser product",
+    "P201" => "Hardback (stationery)",
+    "P202" => "Paperback / softback (stationery)",
+    "P203" => "Spiral bound (stationery)",
+    "P204" => "Leather / fine binding (stationery)",
+    "V201" => "PAL",
+    "V202" => "NTSC",
+    "V203" => "SECAM"
+  }
+end; end

data/lib/cacofonix/codelists/176.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_176 = {
+    "01" => "Android",
+    "02" => "BlackBerry OS",
+    "03" => "iOS",
+    "04" => "Linux",
+    "05" => "Mac OS",
+    "06" => "Mac OS X",
+    "07" => "Palm OS",
+    "08" => "webOS",
+    "09" => "Symbian",
+    "10" => "Windows",
+    "11" => "Windows CE",
+    "12" => "Windows Mobile",
+    "13" => "Mac OS",
+    "14" => "Windows Phone 7"
+  }
+end; end

data/lib/cacofonix/codelists/177.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_177 = {
+    "50" => "Date of birth",
+    "51" => "Date of death"
+  }
+end; end

data/lib/cacofonix/codelists/178.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_178 = {
+    "A103" => "MP3",
+    "A104" => "WAV",
+    "A105" => "Real Audio",
+    "A106" => "WMA",
+    "A107" => "AAC",
+    "D101" => "Real Video",
+    "D102" => "QuickTime",
+    "D103" => "AVI",
+    "D104" => "WMV",
+    "D105" => "MPEG-4",
+    "D106" => "FLV",
+    "D107" => "SWF",
+    "D401" => "PDF",
+    "D501" => "GIF",
+    "D502" => "JPEG",
+    "D503" => "PNG",
+    "D504" => "TIFF",
+    "E101" => "EPUB"
+  }
+end; end

data/lib/cacofonix/codelists/179.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_179 = {
+    "01" => "Proprietary"
+  }
+end; end

data/lib/cacofonix/codelists/184.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+module Cacofonix; module CodeLists
+  LIST_184 = {
+    "00" => "No warning",
+    "01" => "Carries 'CE' logo",
+    "02" => "Carries minimum age warning",
+    "03" => "Carries EU Toy Safety Directive 'Unsuitable for children ages 0-3' warning logo",
+    "04" => "Carries EU Toy Safety Directive hazard warning"
+  }
+end; end

data/lib/cacofonix/core/code.rb

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+
+module Cacofonix
+
+  class Code
+
+    attr_reader :key, :value, :list, :list_number
+
+    # Note re: key type. For backwards compatibility, code keys that are
+    # all-digits are passed around in this gem as Integers.
+    #
+    # The actual code list hashes have string-based keys for consistency. If
+    # you want the integer-or-string key, use Code#key. If you want the real
+    # string key, use Code#to_s.
+    #
+    # If the key is not found in the list, the behaviour depends on the
+    # :enforce option. By default, it returns a code with key and value set to
+    # nil. If :enforce is true, an exception is raised. If :enforce is false,
+    # the key and value is the data given in the tag.
+    #
+    def initialize(list_number, data, options = {})
+      @list_number = list_number
+      unless @list = Cacofonix::Lists.list(@list_number)
+        raise Cacofonix::CodeListNotFound.new(@list_number)
+      end
+
+      @key = @value = nil
+      return  if data.nil? || data == ""
+
+      if data.kind_of?(Integer)
+        @key = data
+        pad_length = options[:length] || ["#{@list.size}".size, 2].max
+        @real_key = pad(data, pad_length)
+      elsif data.match(/^\d+$/) && @list.keys.include?(data)
+        @key = data.to_i
+        @real_key = data
+      elsif @list.keys.include?(data)
+        @key = @real_key = data
+      else
+        @list.each_pair { |k, v|
+          next  unless v == data
+          @real_key = k
+          @key = @real_key.match(/^\d+$/) ? @real_key.to_i : @real_key
+          break
+        }
+      end
+      if @real_key
+        @value = @list[@real_key]
+      elsif options[:enforce] == true
+        raise Cacofonix::CodeNotFoundInList.new(@list_number, data)
+      elsif options[:enforce] == false
+        @value = @key = @real_key = data
+      else
+        @value = @key = @real_key = nil
+      end
+    end
+
+
+    # Returns true if the given key has a value in the codelist.
+    #
+    def valid?
+      @value ? true : false
+    end
+
+
+    # Returns the string representation of the key. eg, "BB".
+    #
+    def to_s
+      @real_key
+    end
+
+
+    # Returns the string representation of the value. eg, "Hardback".
+    #
+    def to_str
+      @value.to_s
+    end
+
+
+    private
+
+      # Converts a Integer key into a String key.
+      #
+      def pad(key, len)
+        key ? key.to_s.rjust(len, '0') : nil
+      end
+
+  end
+
+
+  class CodeListNotFound < ArgumentError
+    def initialize(list_number)
+      @list_number = list_number
+    end
+  end
+
+
+  class CodeNotFoundInList < RuntimeError
+    def initialize(list_number, code)
+      @list_number = list_number
+      @code = code
+    end
+  end
+
+end

data/lib/cacofonix/core/element.rb

@@ -0,0 +1,275 @@
+require "dry/core/class_attributes"
+
+module Cacofonix
+
+  class Element
+    extend Dry::Core::ClassAttributes
+    include ROXML
+
+    defines :xml_array_accessors
+
+    # An accessor to an array of element instances.
+    #
+    # Options:
+    #
+    #   :from - defaults to the class name, but you can override this.
+    #   :singular - accessor is not an array, just a single object.
+    #
+    def self.onix_composite(name, klass, options = {})
+      options[:as] = options.delete(:singular) ? klass : [klass]
+      options[:from] ||= klass.to_s.split("::").last
+      xml_accessor(name, options)
+    end
+
+    # An accessor that treats the input/output as a date.
+    #
+    # Options: none yet.
+    #
+    def self.onix_date_accessor(name, tag_name, options = {})
+      options = options.merge(
+        :from => tag_name,
+        :to_xml => Cacofonix::Formatters.yyyymmdd
+      )
+      if options[:as].kind_of?(Array)
+        prep = lambda { |vs|
+          [vs].flatten.collect { |v| Date.parse(v) rescue nil }
+        }
+      else
+        prep = lambda { |v| Date.parse(v) rescue nil }
+      end
+      xml_accessor(name, options, &prep)
+    end
+
+    # An accessor that treats the input as a space-separated list, and
+    # creates an array for it.
+    #
+    def self.onix_space_separated_list(name, tag_name, options = {})
+      options = options.merge(
+        :from => tag_name,
+        :to_xml => Cacofonix::Formatters.space_separated
+      )
+      prep = lambda { |v| v ? v.split : [] }
+      xml_accessor(name, options, &prep)
+    end
+
+
+    # An accessor that treats an empty string as a true value -- so that
+    # something like <NoContributor /> is recognised as
+    # "there is no contributor".
+    #
+    def self.onix_boolean_flag(name, tag_name, options = {})
+      options = options.merge(
+        :from => tag_name,
+        :to_xml => Cacofonix::Formatters.boolean
+      )
+      prep = lambda { |v| v ? true : false }
+      xml_accessor(name, options, &prep)
+    end
+
+
+    # An accessor that maps a "code" string into an Cacofonix::Code object.
+    # A Code object can return the simple code (or "key"), or the value that
+    # is associated with it in ONIX code lists, and so on.
+    #
+    # Required:
+    #
+    #   :list - integer referring to an ONIX Code List
+    #
+    # Special options for Code instantiation are:
+    #
+    #   :length - how many digits to pad (default is taken from total list size)
+    #
+    # As well as the normal accessor (x/x=), this will create a
+    # special accessor for the richer Code object (#x_code/#x_code=).
+    # For example:
+    #
+    #   class Foo < Cacofonix::Element
+    #     onix_code_from_list(:message_type, "MessageType", :list => 1)
+    #   end
+    #
+    #   foo = Foo.new
+    #
+    #   foo.message_type = 1
+    #
+    #   foo.message_type
+    #   >> 1
+    #
+    #   foo.message_type_code
+    #   >> #<Cacofonix::Code:.......>
+    #
+    #   foo.message_type_code.key
+    #   >> 1
+    #
+    #   foo.message_type_code.to_s
+    #   >> "01"
+    #
+    #   foo.message_type_code.value
+    #   >> "Early notification"
+    #
+    #
+    def self.onix_code_from_list(name, tag_name, options = {})
+      unless list_number = options.delete(:list)
+        raise Cacofonix::CodeListNotSpecified
+      end
+      code_opts = options.slice(:length, :enforce)
+      options.delete(:enforce)
+      prep = lambda { |value|
+        Cacofonix::Code.new(list_number, value, code_opts)
+      }
+      options = options.merge(:from => tag_name)
+      xml_accessor("#{name}_code", options, &prep)
+
+      define_method(name) do
+        send("#{name}_code").key
+      end
+
+      define_method("#{name}=") do |val|
+        val = prep.call(val)  unless val.kind_of?(Cacofonix::Code)
+        send("#{name}_code=", val)
+      end
+    end
+
+    # Like onix_code_from_list, but for an array of codes.
+    #
+    # Required:
+    #
+    #   :list - integer referring to an ONIX Code List
+    #
+    # One important caveat: when assigning to this accessor, you must
+    # pass in the complete array -- if you assign an array that you later
+    # push or shift items into, you might get unexpected results.
+    #
+    # Similar to onix_code_from_list, this creates a special accessor for the
+    # Code objects at (#x_codes/#x_codes=). For example:
+    #
+    #   class Bar < Cacofonix::Element
+    #     onix_codes_from_list(:identifiers, "Identifier", :list => 5)
+    #   end
+    #
+    #   bar = Bar.new
+    #
+    #   bar.identifiers = [1, 5, 13]
+    #
+    #   bar.identifiers_codes.collect { |ids| ids.value }
+    #   >> ["Proprietary", "ISMN-10", "LLCN"]
+    #
+    # If a block is given, each value is passed into it first - return
+    # an array of the actual values.
+    #
+    def self.onix_codes_from_list(name, tag_name, options = {}, &blk)
+      unless list_number = options.delete(:list)
+        raise Cacofonix::CodeListNotSpecified
+      end
+      code_opts = options.slice(:length, :enforce)
+      options.delete(:enforce)
+      prep = lambda { |values|
+        if block_given?
+          values = [values].flatten.collect { |v| blk.call(v) }
+        end
+        [values].flatten.collect do |data|
+          Cacofonix::Code.new(list_number, data, code_opts)
+        end
+      }
+      options = options.merge(:from => tag_name, :as => [])
+      xml_accessor("#{name}_codes", options, &prep)
+
+      define_method(name) do
+        codes = send("#{name}_codes")
+        codes ? codes.collect { |cd| cd.key } : nil
+      end
+
+      # FIXME: Hmm, adding to array? what happens with push, etc?
+      define_method("#{name}=") do |vals|
+        vals = [vals].flatten.collect { |v|
+          v.kind_of?(Cacofonix::Code) ? v : prep.call(v)
+        }.flatten
+        send("#{name}_codes=", vals)
+      end
+    end
+
+
+    # Sugar for a common case -- country or territory codes.
+    #
+    def self.onix_spaced_codes_from_list(name, tag_name, options)
+      options[:to_xml] ||= Cacofonix::Formatters.space_separated
+      onix_codes_from_list(name, tag_name, options) { |v| v ? v.split : [] }
+    end
+
+
+    # Query a composite array within this element, looking for an attribute
+    # ('mthd') that has a value equal to 'query'.
+    #
+    # The idea is that you can shorten this:
+    #
+    #    product.websites.detect { |ws| ws.website_role == 1 }
+    #
+    # To this:
+    #
+    #    product.fetch(:websites, :website_role, 1)
+    #
+    # Note: query may be an array of values, will return the first
+    # composite that matches one of them. So this:
+    #
+    #    product.websites.detect { |ws| ws.website_role == 1 } ||
+    #      product.websites.detect { |ws| ws.website_role == 2 }
+    #
+    # becomes this:
+    #
+    #    product.fetch(:websites, :website_role, [1, 2])
+    #
+    def fetch(composite_symbol, mthd, query)
+      result = nil
+      [query].flatten.each do |matcher|
+        break  if result = send(composite_symbol).detect do |comp|
+          comp.send(mthd) == matcher
+        end
+      end
+      result
+    end
+
+    # Queries a composite array like #fetch, but returns *all* composites
+    # that have a match.
+    #
+    def fetch_all(composite_symbol, mthd, query)
+      [query].flatten.inject([]) do |acc, matcher|
+        comps = send(composite_symbol).select do |comp|
+          comp.send(mthd) == matcher
+        end
+        acc += comps  if comps.any?
+        acc
+      end
+    end
+
+
+    def self.alias_accessor(new_accessor, old_accessor)
+      alias_method(new_accessor, old_accessor)
+      alias_method("#{new_accessor}=", "#{old_accessor}=")
+    end
+
+
+    def self.xml_accessor(attr, *args, **options)
+      if options[:as] && options[:as].kind_of?(Array)
+        xml_array_accessors(Array(xml_array_accessors) + [attr])
+      end
+
+      super
+    end
+
+
+    def initialize(*)
+      if self.class.xml_array_accessors
+        self.class.xml_array_accessors.each do |attr|
+          send :"#{attr}=", []
+        end
+      end
+
+      super
+    end
+
+  end
+
+
+  class CodeListNotSpecified < ArgumentError
+  end
+
+end