bb-epub 0.0.1

data/lib/bb-epub/transform/creator.rb

@@ -0,0 +1,67 @@
+class BbEPUB::Transform::Creator < Bookbinder::Transform
+
+  def dependencies
+    [BbEPUB::Transform::Metadata]
+  end
+
+
+  def to_map(package)
+    return  unless package.map['metadata']
+    return  unless metadata_array = package.map['metadata'][actor_type]
+    actors = []
+    actor_data = metadata_array.sort { |a, b|
+      if a['display-seq'] && b['display-seq']
+        a['display-seq']['@'].to_i <=> b['display-seq']['@'].to_i
+      else
+        0
+      end
+    }
+    actor_data.each { |cdata|
+      actor = {
+        'name' => cdata['@'],
+        'role' => cdata['role'] ? cdata['role']['@'] : 'aut',
+      }
+      actor['file-as'] = cdata['file-as']['@']  if cdata['file-as']
+      # Eh, 'alternate-script' is too messy for now.
+
+      metadata_array.delete(cdata)
+      actors.push(actor)
+    }
+    package.map['metadata'].delete(actor_type)  if metadata_array.empty?
+    package.map[actor_type] = actors
+  end
+
+
+  def from_map(package)
+    return  unless actors = package.map[actor_type]
+    opf_doc = package.file(:opf).document
+    metadata_tag = opf_doc.find('opf|metadata')
+    actors.each_with_index { |actor, seq|
+      actor_tag = opf_doc.new_node('dc:'+actor_type, :append => metadata_tag)
+      actor_tag.content = actor['name']
+      if actors.length > 1
+        seq += 1
+        actor_id = "dc-#{actor_type}-metadata-#{seq}"
+        actor_tag['id'] = actor_id
+        opf_doc.new_node('meta', :append => metadata_tag) { |role_meta_tag|
+          role_meta_tag.content = actor['role']
+          role_meta_tag['property'] = 'role'
+          role_meta_tag['refines'] = '#'+actor_id
+        }
+        opf_doc.new_node('meta', :append => metadata_tag) { |seq_meta_tag|
+          seq_meta_tag.content = seq
+          seq_meta_tag['property'] = 'display-seq'
+          seq_meta_tag['refines'] = '#'+actor_id
+        }
+      end
+    }
+  end
+
+
+  protected
+
+    def actor_type
+      'creator'
+    end
+
+end

data/lib/bb-epub/transform/description.rb

@@ -0,0 +1,43 @@
+class BbEPUB::Transform::Description < Bookbinder::Transform
+
+  def dependencies
+    [BbEPUB::Transform::Metadata]
+  end
+
+
+  def to_map(package)
+    desc_hashes = package.map['metadata'].delete('description')
+    descs = []
+    if desc_hashes && desc_hashes.any?
+      descs = desc_hashes.collect { |dh| dh['@'] }
+      descs.sort! { |a, b| a.length <=> b.length }
+      full = descs.shift
+      if full && !full.empty?
+        short = descs.shift || first_sentence(full)
+        desc = { 'full' => full }
+        desc['short'] = short  if short
+        package.map['description'] = desc
+      end
+    end
+  end
+
+
+  def from_map(package)
+    if desc = package.map['description']
+      opf_doc = package.file(:opf).document
+      opf_doc.new_node('dc:description', :append => 'opf|metadata') { |desc_tag|
+        desc_tag.content = desc['full']
+      }
+    end
+  end
+
+
+  protected
+
+    def first_sentence(str)
+      str = Nokogiri::HTML(str).text
+      sentences = str.split(/\./)
+      sentences.first+'.'  if sentences.any?
+    end
+
+end

data/lib/bb-epub/transform/language.rb

@@ -0,0 +1,29 @@
+class BbEPUB::Transform::Language < Bookbinder::Transform
+
+  def dependencies
+    [BbEPUB::Transform::Metadata]
+  end
+
+
+  def to_map(package)
+    lang_hashes = package.map['metadata'].delete('language')
+    if lang_hashes && lang_hashes.any?
+      package.map['language'] = lang_hashes.collect { |lh| lh['@'] }
+    else
+      package.warn('No <dc:language> found in OPF metadata')
+    end
+  end
+
+
+  def from_map(package)
+    if langs = package.map['language']
+      opf_doc = package.file(:opf).document
+      langs.each { |lang|
+        opf_doc.new_node('dc:language', :append => 'opf|metadata') { |lang_tag|
+          lang_tag.content = lang
+        }
+      }
+    end
+  end
+
+end

data/lib/bb-epub/transform/metadata.rb

@@ -0,0 +1,143 @@
+# Takes all the elements in the <metadata> tag of the OPF file and
+# generates a clean hash of the data. Other transforms will pick and
+# choose from this hash. What's left over is mostly just for
+# preserving EPUB's guff.
+#
+# So this:
+#
+#    <metadata>
+#      <dc:identifier id="isbn-id">
+#        urn:isbn:9780101010101
+#      </dc:identifier>
+#      <meta
+#        refines="#isbn-id"
+#        property="identifier-type"
+#        scheme="onix:codelist5"
+#      >
+#        15
+#      </meta>
+#      <dc:source id="src-id">
+#        urn:isbn:9780375704024
+#      </dc:source>
+#      <meta
+#        refines="#src-id"
+#        property="identifier-type"
+#        scheme="onix:codelist5"
+#      >
+#        15
+#      </meta>
+#    </metadata>
+#
+# ... becomes this:
+#
+#    "metadata": {
+#      "identifier": [{
+#        "@": "urn:isbn:9780101010101",
+#        "identifier-type": {
+#          "@": 15,
+#          "scheme": {
+#            "@": "onix-codelist5"
+#          }
+#        }
+#      }],
+#      "source": [{
+#        "@": "urn:isbn:9780375704024",
+#        "identifier-type": {
+#          "@": 15,
+#          "scheme": {
+#            "@": "onix-codelist5"
+#          }
+#        }
+#      }]
+#    }
+#
+# You can nest properties arbitrarily deep in the map's "metadata" structure.
+#
+#     "metadata": {
+#       "some-property": [{
+#         "@": "value-of-some-property",
+#         "some-property-property": {
+#           "@": "value-of-some-property-property",
+#           "some-property-property-property": {
+#             "@": "value-of-etc"
+#           }
+#         }
+#       }],
+#       "other-property": [
+#         { "@": "other-property-first-value" },
+#         { "@": "other-property-second-value" }
+#       ]
+#     }
+#
+class BbEPUB::Transform::Metadata < Bookbinder::Transform
+
+
+  def dependencies
+    [BbEPUB::Transform::OPF]
+  end
+
+
+  def to_map(package)
+    opf_doc = package.file(:opf).document('r')
+    md = {}
+    opf_doc.each('opf|metadata > *') { |tag|
+      # If this tag refines another metadata tag, we can skip it
+      if refines = tag['refines']
+        refines = "opf|metadata > *[id=\"#{refines.sub(/^#/,'')}\"]"
+        next if opf_doc.find(refines)
+      end
+
+      # Find the basic name and value of the meta tag
+      name = tag.node_name
+      value = { '@' => tag.content.strip }
+      # If the meta tag has attributes, add them to the value
+      # (but note that these are deprecated in EPUB3 in favor
+      # of refinements).
+      tag.attributes.each_pair { |key, attr|
+        value[key] = { '@' => attr.value }
+        value[key]['deprecated'] = true  unless key == 'id' || key == 'refines'
+      }
+      if name == 'meta'
+        if tag['property']
+          name = tag['property']
+          value.delete('property')
+        elsif tag['name']
+          # Note that <meta name="" content=""> is deprecated in EPUB3.
+          name = tag['name']
+          value['@'] = tag['content']
+          value['deprecated'] = true
+          value.delete('name')
+        end
+      end
+      # If the meta tag is refined by another meta tag, add the
+      # refinements to our value hash.
+      if tag['id']
+        refines = opf_doc.search(
+          'opf|metadata > opf|meta[refines="#'+tag['id']+'"]'
+        )
+        refines.each { |refinement|
+          refine_value = { '@' => refinement.content.strip }
+          refinement.attributes.each_pair { |key, attr|
+            refine_value[key] = attr.value
+          }
+          value[refinement['property']] = refine_value
+        }
+      end
+      # Add the name and value to our metadata hash
+      add_to_hash(md, name, value)
+    }
+    package.map['metadata'] = md
+  end
+
+
+  def from_map(package)
+  end
+
+
+  protected
+
+    def add_to_hash(hash, key, val)
+      hash[key] = [hash[key], val].flatten.compact
+    end
+
+end

data/lib/bb-epub/transform/nav.rb

@@ -0,0 +1,60 @@
+class BbEPUB::Transform::Nav < Bookbinder::Transform
+
+  DEFAULT_FILE_NAME = 'book-nav.xhtml'
+
+  def dependencies
+    [BbEPUB::Transform::Resources]
+  end
+
+
+  def to_map(package)
+    opf_doc = package.file(:opf).document('r')
+    if nav_item = opf_doc.find('opf|manifest > opf|item[properties~="nav"]')
+      nav_path = package.make_path(nav_item['href'])
+      package.file_aliases[:nav] = nav_path
+      package.map['resources'].delete_if { |rsrc|
+        package.file_path(rsrc['path']) == nav_path
+      }
+    end
+  end
+
+
+  def from_map(package)
+    if package.options['nav_file'] != false
+      stub_nav(package)
+      add_to_opf_manifest(package)
+    end
+  end
+
+
+  protected
+
+    def stub_nav(package)
+      package.file_aliases[:nav] = DEFAULT_FILE_NAME
+      package.file(:nav).new_xml_document { |doc, x|
+        x.doc.create_internal_subset('html', nil, nil)
+        x.html {
+          doc.add_node_namespace(x.parent, 'xhtml', true)
+          doc.add_node_namespace(x.parent, 'epub')
+          x.head {
+            x.meta('charset' => 'utf-8')
+            x.style('ol { list-style: none; }')
+          }
+          x.body
+        }
+      }
+    end
+
+
+    def add_to_opf_manifest(package)
+      opf_file = package.file(:opf)
+      nav_file = package.file(:nav)
+      opf_file.document.new_node('item', :append => 'opf|manifest') { |item_tag|
+        item_tag['href'] = package.make_href(DEFAULT_FILE_NAME)
+        item_tag['id'] = package.make_id(DEFAULT_FILE_NAME)
+        item_tag['properties'] = 'nav'
+        item_tag['media-type'] = nav_file.media_type
+      }
+    end
+
+end

data/lib/bb-epub/transform/nav_toc.rb

@@ -0,0 +1,177 @@
+class BbEPUB::Transform::NavToc < Bookbinder::Transform
+
+  def dependencies
+    [BbEPUB::Transform::Nav, BbEPUB::Transform::NCX]
+  end
+
+
+  def to_map(package)
+    toc = []
+    package.if_file(:nav) { |nav_file|
+      nav_doc = nav_file.document('r')
+      base_path = content_rooted_path(package.content_root, nav_file.path)
+      nav_doc.each('nav[epub|type="toc"] > ol > li') { |li|
+        toc.push(extract_nav_chapter(nav_doc, li, base_path))
+      }
+    }
+    unless toc.any?
+      package.if_file(:ncx) { |ncx_file|
+        ncx_doc = ncx_file.document
+        base_path = content_rooted_path(package.content_root, ncx_file.path)
+        ncx_doc.each('ncx|navMap > ncx|navPoint') { |point|
+          toc.push(extract_ncx_chapter(ncx_doc, point, base_path))
+        }
+      }
+    end
+    if toc.any?
+      package.map['nav'] ||= {}
+      package.map['nav']['toc'] = toc
+    end
+  end
+
+
+  def from_map(package)
+    package.if_file(:ncx) { |ncx_file|
+      @max_depth = 0
+      @chapter_count = 0
+      toc = (package.map['nav'] || {})['toc'] || []
+      build_ncx_map(ncx_file.document, toc)
+      build_ncx_depth_meta(ncx_file.document, @max_depth)
+    }
+    package.if_file(:nav) { |nav_file|
+      toc = (package.map['nav'] || {})['toc'] || []
+      build_nav_tag(nav_file.document, toc)
+    }
+  end
+
+
+  protected
+
+    # NAV to_map
+
+    def extract_nav_chapter(doc, li, base_path)
+      {}.tap { |chp|
+        content_node = doc.find_within(li, '> a, span')
+        chp['title'] = content_node['title'] || content_node.content.strip
+        if content_node.node_name.downcase == 'a'
+          chp['path'] = resolved_path(base_path, content_node['href'])
+        end
+        children = doc.search_within(li, '> li')
+        if children.any?
+          chp['contents'] = children.collect { |child|
+            extract_nav_chapter(doc, child, base_path)
+          }
+        end
+      }
+    end
+
+
+    # NCX to_map
+
+    def extract_ncx_chapter(doc, point, base_path)
+      {
+        'title' => doc.find_within(point, 'text').text,
+        'path' => resolved_path(
+          base_path,
+          doc.find_within(point, 'content')['src']
+        )
+      }.tap { |out|
+        children = doc.search_within(point, '> navPoint')
+        if children.any?
+          out['contents'] = children.collect { |pt|
+            extract_ncx_chapter(doc, pt, base_path)
+          }
+        end
+      }
+    end
+
+
+    # NAV from_map
+
+    def build_nav_tag(nav_doc, toc)
+      nav_tag_frag = Nokogiri::XML::DocumentFragment.parse('')
+      Nokogiri::XML::Builder.with(nav_tag_frag) { |x|
+        x.nav('epub:type' => 'toc') { build_nav_ol_for_chapters(x, toc) }
+      }
+      nav_doc.find('body').add_child(nav_tag_frag)
+    end
+
+
+    def build_nav_ol_for_chapters(x, chapters)
+      x.ol {
+        chapters.each { |chp|
+          x.li {
+            atts = { 'href' => chp['path'] }
+            x.a(chp['title'], atts)
+            build_nav_ol_for_chapters(x, chp['contents'])  if chp['contents']
+          }
+        }
+      }
+    end
+
+
+    # NCX from_map
+
+    def build_ncx_map(ncx_doc, toc)
+      nav_map_frag = Nokogiri::XML::DocumentFragment.parse('')
+      Nokogiri::XML::Builder.with(nav_map_frag) { |x|
+        x.navMap {
+          toc.each { |chp| build_ncx_point_for_chapter(x, chp, 0) }
+        }
+      }
+      ncx_doc.root.add_child(nav_map_frag)
+    end
+
+
+    def build_ncx_depth_meta(ncx_doc, max_depth)
+      ncx_doc.new_node('meta', :append => 'ncx|head') { |depth_meta_tag|
+        depth_meta_tag['name'] = 'dtb:depth'
+        depth_meta_tag['content'] = max_depth
+      }
+    end
+
+
+    def build_ncx_point_for_chapter(x, chp, depth)
+      @chapter_count += 1
+      depth += 1
+      @max_depth = depth  if depth > @max_depth
+      x.navPoint(
+        'id' => "toc-#{@chapter_count}",
+        'class' => 'chapter',
+        'playOrder' => @chapter_count
+      ) {
+        x.navLabel { x.text_(chp['title']) }
+        x.content('src' => chp['path'])
+        if chp['children']
+          chp['children'].each { |chd|
+            build_ncx_point_for_chapter(x, chd, depth)
+          }
+        end
+      }
+    end
+
+
+    # Utilities
+    def content_rooted_path(content_root, path)
+      File.dirname(path).sub(/^#{content_root}\/?/, '').sub(/^\.$/, '')
+    end
+
+
+    def resolved_path(base_path, path)
+      relative_path = File.join(base_path, path).sub(/^\//, '')
+      relative_parts = relative_path.split('/')
+      resolved_parts = []
+      while relative_parts.any?
+        part = relative_parts.shift
+        if part == '.'
+          # do nothing
+        elsif part == '..'
+          resolved_parts.pop
+        else
+          resolved_parts.push(part)
+        end
+      end
+      File.join(resolved_parts)
+    end
+
+end

data/lib/bb-epub/transform/ncx.rb

@@ -0,0 +1,63 @@
+class BbEPUB::Transform::NCX < Bookbinder::Transform
+
+  DEFAULT_FILE_NAME = 'book.ncx'
+
+
+  def dependencies
+    [BbEPUB::Transform::Resources]
+  end
+
+
+  def to_map(package)
+    opf_doc = package.file(:opf).document('r')
+    spine = opf_doc.find('opf|spine')
+    if spine && ncx_id = spine['toc']
+      ncx_item = opf_doc.find('opf|manifest > opf|item[id="'+ncx_id+'"]')
+      ncx_path = package.make_path(ncx_item['href'])
+      package.file_aliases[:ncx] = ncx_path
+      package.map['resources'].delete_if { |rsrc|
+        package.file_path(rsrc['path']) == ncx_path
+      }
+    end
+  end
+
+
+  def from_map(package)
+    if package.options['ncx_file'] != false
+      stub_ncx(package)
+      add_to_opf_manifest(package)
+    end
+  end
+
+
+  protected
+
+    def stub_ncx(package)
+      package.file_aliases[:ncx] = DEFAULT_FILE_NAME
+      package.file(:ncx).new_xml_document { |doc, x|
+        x.ncx('version' => '2005-1', 'xml:lang' => 'en') {
+          doc.add_node_namespace(x.parent, 'ncx', true)
+          x.head {
+            x.meta(
+              'name' => 'dtb:generator',
+              'content' => "Bookbinder #{Bookbinder::VERSION}"
+            )
+          }
+        }
+      }
+    end
+
+
+    def add_to_opf_manifest(package)
+      opf_file = package.file(:opf)
+      ncx_file = package.file(:ncx)
+      ncx_id = package.make_id(DEFAULT_FILE_NAME)
+      opf_file.document.new_node('item', :append => 'opf|manifest') { |item_tag|
+        item_tag['href'] = package.make_href(DEFAULT_FILE_NAME)
+        item_tag['media-type'] = ncx_file.media_type
+        item_tag['id'] = ncx_id
+      }
+      opf_file.document.find('opf|spine')['toc'] = ncx_id
+    end
+
+end

data/lib/bb-epub/transform/ocf.rb

@@ -0,0 +1,33 @@
+class BbEPUB::Transform::OCF < Bookbinder::Transform
+
+  OCF_PATH = 'META-INF/container.xml'
+
+  # No dependencies! Something has to have no dependencies, after all.
+
+  def to_map(package)
+    package.file_aliases[:ocf] = OCF_PATH
+    ocf = package.file(:ocf, false)
+    opf_path = ocf.document('r').find('ocf|rootfile')['full-path']
+    package.file_aliases[:opf] = File.basename(opf_path)
+    package.content_root = File.dirname(opf_path).sub(/^\./, '')
+  end
+
+
+  def from_map(package)
+    package.file_aliases[:ocf] = OCF_PATH
+    package.file_aliases[:opf] = 'book.opf'
+    opf_file = package.file(:opf)
+    package.file(:ocf, false).new_xml_document { |doc, x|
+      x.container('version' => '1.0') {
+        doc.add_node_namespace(x.parent, 'ocf', true)
+        x.rootfiles {
+          x.rootfile(
+            'full-path' => opf_file.path,
+            'media-type' => opf_file.media_type
+          )
+        }
+      }
+    }
+  end
+
+end

data/lib/bb-epub/transform/opf.rb

@@ -0,0 +1,22 @@
+class BbEPUB::Transform::OPF < Bookbinder::Transform
+
+  def dependencies
+    [BbEPUB::Transform::OCF]
+  end
+
+
+  def from_map(package)
+    package.file(:opf).new_xml_document { |opf_doc, x|
+      x.package('version' => '3.0') {
+        opf_doc.add_node_namespace(x.parent, 'opf', true)
+        x.metadata {
+          opf_doc.add_node_namespace(x.parent, 'dc')
+          opf_doc.add_node_namespace(x.parent, 'dcterms')
+        }
+        x.manifest
+        x.spine
+      }
+    }
+  end
+
+end