gepub 0.5.0 → 0.6.0

data/lib/gepub/item.rb

@@ -1,21 +1,76 @@
 module GEPUB
   class Item
-    attr_accessor :itemid, :href, :mediatype, :content
+    attr_accessor :content
+    def self.create(parent, attributes = {})
+      Item.new(attributes['id'], attributes['href'], attributes['media-type'], parent,
+               attributes.reject { |k,v| ['id','href','media-type'].member?(k) })
+    end
+
+    def initialize(itemid, itemhref, itemmediatype = nil, parent = nil, attributes = {})
+      if attributes['properties'].class == String
+        attributes['properties'] = attributes['properties'].split(' ')
+      end
+      @attributes = {'id' => itemid, 'href' => itemhref, 'media-type' => itemmediatype}.merge(attributes)
+      @attributes['media-type'] =  guess_mediatype if media_type.nil?
+      @parent = parent
+      @parent.register_item(self) unless @parent.nil?
+      self
+    end
+
+    ['id', 'href', 'media-type', 'fallback', 'properties', 'media-overlay'].each { |name|
+      methodbase = name.sub('-','_')
+      define_method(methodbase + '=') { |val| @attributes[name] = val }
+      define_method('set_' + methodbase) { |val| @attributes[name] = val }
+      define_method(methodbase) { @attributes[name] }
+    }
+
+    def itemid
+      id
+    end
+
+    def mediatype
+      media_type
+    end
+    
+    def [](x)
+      @attributes[x]
+    end
 
-    def initialize(itemid, href, mediatype = nil)
-      @itemid = itemid
-      @href = href
-      @mediatype = mediatype || guess_mediatype
+    def []=(x,y)
+      @attributes[x] = y
+    end
+    
+    def add_property(property)
+      (@attributes['properties'] ||=[]) << property
+      self
     end
 
+    def cover_image
+      add_property('cover-image')
+    end
+
+    def add_raw_content(data)
+      @content = data
+    end
     def add_content(io)
       io.binmode
       @content = io.read
       self
     end
-    
+
+    def to_xml(builder, opf_version = '3.0')
+      attr = @attributes.dup
+      if opf_version.to_f < 3.0
+        attr.reject!{ |k,v| k == 'properties' }
+      end
+      if !attr['properties'].nil?
+        attr['properties'] = attr['properties'].join(' ')
+      end
+      builder.item(attr)
+    end
+
     def guess_mediatype
-      case File.extname(@href)
+      case File.extname(href)
       when /.(html|xhtml)/i
         'application/xhtml+xml'
       when /.css/i
@@ -34,6 +89,10 @@ module GEPUB
         'application/oebps-package+xml'
       when /.ncx/i
         'application/x-dtbncx+xml'
+      when /.(otf|ttf|ttc)/i
+        'application/vnd.ms-opentype'
+      when /.woff/i
+        'application/font-woff'
       end
     end
   end

data/lib/gepub/manifest.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'nokogiri'
+module GEPUB
+  class Manifest
+    include XMLUtil
+    attr_accessor :opf_version
+    def self.parse(manifest_xml, opf_version = '3.0', id_pool = Package::IDPool.new)
+      Manifest.new(opf_version, id_pool) {
+        |manifest|
+        manifest.instance_eval {
+          @xml = manifest_xml
+          @namespaces = @xml.namespaces
+          @attributes = attr_to_hash(@xml.attributes)
+          @items = {}
+          @items_by_href = {}
+          @xml.xpath("//#{ns_prefix(OPF_NS)}:manifest/#{ns_prefix(OPF_NS)}:item", @namespaces).map {
+            |item|
+            i = Item.create(self, attr_to_hash(item.attributes))
+            @items[i.id] = i
+            @items_by_href[i.href] = i
+          }
+        }
+      }
+    end
+
+    def id=(val)
+      @attributes['id'] = val
+    end
+
+    def id
+      @attributes['id']
+    end
+
+    def initialize(opf_version = '3.0', id_pool = Package::IDPool.new)
+      @id_pool = id_pool
+      @attributes = {}
+      @items = {}
+      @items_by_href = {}
+      @opf_version = opf_version
+      yield self if block_given?
+    end
+
+    def item_list
+      @items.dup
+    end
+
+    def item_by_href(href)
+      @items_by_href[href]
+    end
+    
+    def add_item(id,href,media_type, attributes = {})
+      @items[id] = item = Item.new(id,href,media_type,self, attributes)
+      @items_by_href[href] = item
+      item
+    end
+
+    def to_xml(builder)
+      builder.manifest(@attributes) {
+        @items.each {
+          |itemid, item|
+          item.to_xml(builder, @opf_version)
+        }
+      }
+    end
+    
+    def register_item(item)
+      raise "id '#{item.id}' is already in use." if @id_pool[item.id]
+      @id_pool[item.id] = true
+    end
+
+    def unregister_item(item)
+      @items[item.id] = nil
+      @items_by_href[item.href] = nil
+      @id_pool[item.id] = nil
+    end
+    
+  end
+end

data/lib/gepub/meta.rb

@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'nokogiri'
+
+module GEPUB
+  # Holds one metadata with refine meta elements.
+  class Meta
+    attr_accessor :content
+    attr_reader :name
+    def initialize(name, content, parent, attributes= {}, refiners = {})
+      @parent = parent
+      @name = name
+      @content = content
+      @attributes = attributes
+      @refiners = refiners
+      @parent.register_meta(self) unless @parent.nil?
+    end
+
+    def [](x)
+      @attributes[x]
+    end
+
+    def []=(x,y)
+      @attributes[x] = y
+    end
+
+    def refiner_list(name)
+      return @refiners[name].dup
+    end
+
+    def refiner_clear(name)
+      if !@refiners[name].nil?
+        @refiners[name].each {
+          |refiner|
+          @parent.unregister_meta(refiner)
+        }
+      end
+      @refiners[name]= []
+    end
+
+    def refiner(name)
+      refiner = @refiners[name]
+      if refiner.nil? || refiner.size == 0
+        nil
+      else
+        refiner[0]
+      end
+    end
+
+    # add a refiner.
+    def add_refiner(property, content, attributes = {})
+      (@refiners[property] ||= []) << refiner = Meta.new('meta', content, @parent, { 'property' => property }.merge(attributes)) unless content.nil?
+      self
+    end
+
+    # set a 'unique' refiner. all other refiners with same property will be removed.
+    def refine(property, content, attributes = {})
+      if !content.nil?
+        refiner_clear(property)
+        add_refiner(property, content, attributes)
+      end
+      self
+    end
+
+    ['title-type', 'identifier-type', 'display-seq', 'file-as', 'group-position'].each {
+      |name|
+      methodbase = name.sub('-','_')
+      define_method(methodbase + '=') { |val| refine(name, val); }
+      define_method('set_' + methodbase) { |val| refine(name, val); }        
+      define_method(methodbase) { refiner(name) }
+    }
+
+    # add alternate script refiner.
+    def add_alternates(alternates = {})
+      alternates.each {
+        |locale, content|
+        add_refiner('alternate-script', content, { 'xml:lang' => locale })
+      }
+      self
+    end
+
+    def to_xml(builder, id_pool, ns = nil, additional_attr = {}, opf_version = '3.0')
+      additional_attr ||= {}
+      if @refiners.size > 0 && opf_version.to_f >= 3.0
+        @attributes['id'] = id_pool.generate_key(:prefix => name) if @attributes['id'].nil?
+      end
+
+      # using eval to parametarize Namespace and content.
+      eval "builder#{ ns.nil? || @name == 'meta' ? '' : '[ns]'}.#{@name}(@attributes.reject{|k,v| v.nil?}.merge(additional_attr)#{@content.nil? ? '' : ',  @content'})"
+
+      if @refiners.size > 0 && opf_version.to_f >= 3.0
+        additional_attr['refines'] = "##{@attributes['id']}"
+        @refiners.each {
+          |k, ref_list|
+          ref_list.each {
+            |ref|
+            ref.to_xml(builder, id_pool, nil, additional_attr)
+          }
+        }
+      end
+    end
+    
+    def to_s(locale=nil)
+      localized = nil
+      if !locale.nil?
+        prefix = locale.sub(/^(.+?)-.*/, '\1')
+        regex = Regexp.new("^((" + locale.split('-').join(')?-?(') + ")?)")
+        candidates = @refiners['alternate-script'].select {
+          |refiner|
+          refiner['xml:lang'] =~ /^#{prefix}-?.*/
+        }.sort_by {
+          |x|
+          x['xml:lang'] =~ regex; $1.size
+        }.reverse
+        localized = candidates[0].content if candidates.size > 0
+      end
+      (localized || @content || super).to_s
+    end
+  end
+end

data/lib/gepub/metadata.rb

@@ -0,0 +1,230 @@
+require 'rubygems'
+require 'nokogiri'
+require 'time'
+
+module GEPUB
+  # metadata constants
+  module TITLE_TYPE
+    ['main','subtitle', 'short', 'collection', 'edition','expanded'].each {
+      |type|
+      const_set(type.upcase, type)
+    }
+  end
+  # Holds data in /package/metadata 
+  class Metadata
+    include XMLUtil
+    attr_accessor :opf_version
+    # parse metadata element. metadata_xml should be Nokogiri::XML::Node object.
+    def self.parse(metadata_xml, opf_version = '3.0', id_pool = Package::IDPool.new)
+      Metadata.new(opf_version, id_pool) {
+        |metadata|
+        metadata.instance_eval {
+          @xml = metadata_xml
+          @namespaces = @xml.namespaces
+          CONTENT_NODE_LIST.each {
+            |node|
+            i = 0
+            @content_nodes[node] = parse_node(DC_NS, node).sort_by {
+              |v|
+              [v.refiner('display-seq').to_s.to_i || 2 ** (0.size * 8 - 2) - 1, i += 1]
+            }              
+          }
+          @xml.xpath("#{ns_prefix(OPF_NS)}:meta[not(@refines) and @property]", @namespaces).each {
+            |node|
+            @meta[node['property']] = create_meta(node)
+          }
+
+          @oldstyle_meta = parse_opf2_meta
+        }
+      }
+    end
+    
+    def initialize(opf_version = '3.0',id_pool = Package::IDPool.new)
+      @id_pool = id_pool
+      @metalist = {}
+      @content_nodes = {}
+      @meta = {}
+      @oldstyle_meta = []
+      @opf_version = opf_version
+      @namespaces = { 'xmlns:dc' =>  DC_NS }
+      @namespaces['xmlns:opf'] = OPF_NS if @opf_version.to_f < 3.0 
+      yield self if block_given?
+    end
+
+    def to_xml(builder)
+      builder.metadata(@namespaces) {
+        @content_nodes.each {
+          |name, list|
+          list.each {
+            |meta|
+            meta.to_xml(builder, @id_pool, ns_prefix(DC_NS), nil, @opf_version)
+          }
+        }
+        @oldstyle_meta.each {
+          |node|
+          node.to_xml(builder, @id_pool, nil)
+        }
+      }
+      @xml
+    end
+
+    def main_title # should make it obsolete? 
+      @content_nodes['title'][0].content
+    end
+
+    def oldstyle_meta
+      @oldstyle_meta.dup
+    end
+
+    def oldstyle_meta_clear
+      @oldstyle_meta.each {
+        |meta|
+        unregister_meta(meta)
+      }
+      @oldstyle_meta = []
+    end
+    
+    CONTENT_NODE_LIST = ['identifier','title', 'language', 'contributor', 'creator', 'coverage', 'date','description','format ','publisher','relation','rights','source','subject','type'].each {
+      |node|
+      define_method(node + '_list') { @content_nodes[node].dup }
+      define_method(node + '_clear') {
+        if !@content_nodes[node].nil?
+          @content_nodes[node].each { |x| unregister_meta(x) };
+          @content_nodes[node] = []
+        end
+      }
+
+      #TODO: should override for 'title'. // for 'main title' not always comes first.
+      define_method(node) {
+        if !@content_nodes[node].nil? && @content_nodes[node].size > 0
+          @content_nodes[node][0]
+        end
+      }
+
+      define_method('add_' + node) {
+        |content, id|
+        add_metadata(node, content, id)
+      }
+      
+      define_method('set_' + node) {
+        |content, id|
+        send(node + "_clear")
+        add_metadata(node, content, id)
+      }
+      
+      define_method(node+'=') {
+        |content|
+        send(node + "_clear")
+        add_metadata(node, content)
+      }
+    }
+
+    def add_identifier(string, id, type=nil)
+      raise 'id #{id} is already in use' if @id_pool[id]
+      identifier = add_metadata('identifier', string, id)
+      identifier.refine('identifier-type', type) unless type.nil?
+      identifier
+    end
+
+    def identifier_by_id(id)
+      @content_nodes['identifier'].each {
+        |x|
+        return x.content if x['id'] == id
+      }
+    end
+    
+    def add_metadata(name, content, id = nil)
+      meta = Meta.new(name, content, self, { 'id' => id })
+      (@content_nodes[name] ||= []) << meta
+      yield self if block_given?
+      meta
+    end
+
+    def add_title(content, id = nil, title_type = nil)
+      meta = add_metadata('title', content, id).refine('title-type', title_type)
+      yield meta if block_given?
+      meta
+    end
+    
+    def add_person(name, content, id = nil, role = 'aut')
+      meta = add_metadata(name, content, id).refine('role', role)
+      yield meta if block_given?
+      meta
+    end
+
+    def add_creator(content, id = nil, role = 'aut')
+      meta = add_person('creator', content, id, role)
+      yield meta if block_given?
+      meta
+    end
+
+    def add_contributor(content, id=nil, role=nil)
+      meta = add_person('contributor', content, id, role)
+      yield meta if block_given?
+      meta
+    end
+    
+    def set_lastmodified(date=nil)
+      date ||= Time.now
+      (@content_nodes['meta'] ||= []).each {
+        |meta|
+        if (meta['property'] == 'dcterms:modified')
+          @content_nodes['meta'].delete meta
+        end
+      }
+      add_metadata('meta', date.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))['property'] = 'dcterms:modified'
+    end
+
+    def add_oldstyle_meta(content, attributes = {})
+      meta = Meta.new('meta', content, self, attributes)
+      (@oldstyle_meta ||= []) << meta
+      meta
+    end
+
+    
+    def register_meta(meta)
+      if !meta['id'].nil?
+        raise "id '#{meta['id']}' is already in use." if @id_pool[meta['id']]
+        @metalist[meta['id']] =  meta 
+        @id_pool[meta['id']] = true
+      end
+    end
+
+    def unregister_meta(meta)
+      if meta['id'].nil?
+        @metalist[meta['id']] =  nil
+        @id_pool[meta['id']] = nil
+      end
+    end
+    
+    private
+    def parse_node(ns, node)
+      @xml.xpath("#{ns_prefix(ns)}:#{node}", @namespaces).map {
+        |node|
+        create_meta(node)
+      }
+    end
+
+    def create_meta(node)
+      Meta.new(node.name, node.content, self, attr_to_hash(node.attributes), collect_refiners(node['id']))
+    end
+
+    def collect_refiners(id)
+      r = {}
+      if !id.nil? 
+        @xml.xpath("//#{ns_prefix(OPF_NS)}:meta[@refines='##{id}']", @namespaces).each {
+          |node|
+          (r[node['property']] ||= []) << create_meta(node)
+        }
+      end
+      r
+    end
+
+    def parse_opf2_meta
+      @xml.xpath("#{ns_prefix(OPF_NS)}:meta[not(@refines) and not(@property)]").map {
+            |node|
+            create_meta(node)
+      }
+    end
+  end
+end