bookshelf 1.2.1 → 1.2.4

data/lib/bookshelf/parser/epub.rb

@@ -1,132 +1,209 @@
 module Bookshelf
   module Parser
     class Epub < Base
-      def sections
-        @sections ||= html.css("div.chapter").each_with_index.map do |chapter, index|
-          OpenStruct.new({
-            :index    => index,
-            :filename => "section_#{index}.html",
-            :filepath => tmp_dir.join("section_#{index}.html").to_s,
-            :html     => Nokogiri::HTML(chapter.inner_html)
-          })
-        end
+      def html
+        @html ||= Nokogiri::HTML(html_path.read)
       end
 
-      def epub
-        @epub ||= EeePub::Maker.new
+      def chapters
+        @chapters ||= []
       end
 
-      def html
-        @html ||= Nokogiri::HTML(html_path.read)
+      def assets
+        @assets ||= []
       end
 
       def parse
-        epub.title        config[:title]
-        epub.language     config[:language]
-        epub.creator      config[:authors].to_sentence
-        epub.publisher    config[:publisher]
-        epub.date         config[:published_at]
-        epub.uid          config[:uid]
-        epub.identifier   config[:identifier][:id], :scheme => config[:identifier][:type]
-        epub.cover_page   cover_image if cover_image && File.exist?(cover_image)
-
-        write_sections!
-        write_toc!
-
-        epub.files    sections.map(&:filepath) + assets
-        epub.nav      navigation
-        epub.toc_page toc_path
-
-        epub.save(epub_path)
-
+        _create_directories
+        _create_container_xml
+        _create_cover_html
+        _create_chapter_html
+        _create_toc_html
+        _create_toc_ncx
+        _create_assets
+        _create_content_opf
+        _create_epub
         true
       rescue Exception
         p $!, $@
         false
       end
 
-      def write_toc!
-        toc = TOC::Epub.new(navigation)
+      def _create_directories
+        FileUtils.rm_rf(tmp_path)
+        FileUtils.mkdir_p(tmp_path)
+        FileUtils.mkdir_p(File.join(tmp_path, "META-INF"))
+        FileUtils.mkdir_p(File.join(tmp_path, "styles"))
+        FileUtils.mkdir_p(File.join(tmp_path, "fonts"))
+        FileUtils.mkdir_p(File.join(tmp_path, "images"))
+      end
 
-        File.open(toc_path, "w") do |file|
-          file << toc.to_html
+      def _create_container_xml
+        builder = Nokogiri::XML::Builder.new("encoding" => "utf-8") do |xml|
+          xml.container("xmlns" => "urn:oasis:names:tc:opendocument:xmlns:container", "version" => "1.0") {
+            xml.rootfiles {
+              xml.rootfile "full-path" => "content.opf", "media-type" => "application/oebps-package+xml"
+            }
+          }
+        end
+        File.open(File.join(tmp_path, "META-INF", "container.xml"), "w") do |f|
+          f.write(builder.to_xml)
         end
       end
 
-      def write_sections!
-        # First we need to get all ids, which are used as
-        # the anchor target.
-        #
-        links = sections.inject({}) do |buffer, section|
-          section.html.css("[id]").each do |element|
-            anchor = "##{element["id"]}"
-            buffer[anchor] = "#{section.filename}#{anchor}"
-          end
-
-          buffer
+      def _create_cover_html
+        File.open(File.join(tmp_path, "cover.html"), "w") do |f|
+          f.write(Bookshelf.render_template(cover_template_path, :title => config[:title], :authors => config[:authors]))
         end
+      end
 
-        # Then we can normalize all links and
-        # manipulate other paths.
-        #
-        sections.each do |section|
-          section.html.css("a[href^='#']").each do |link|
-            href = link["href"]
-            link.set_attribute("href", links.fetch(href, href))
-          end
-
-          # Replace all srcs.
-          #
-          section.html.css("[src]").each do |element|
-            src = File.basename(element["src"]).gsub(/\.svg$/, ".png")
-            element.set_attribute("src", src)
-            element.set_attribute("alt", "")
-            element.node_name = "img"
+      def _create_chapter_html
+        html.css("div.chapter").each_with_index.map do |chapter, index|
+          filename = "chapter_#{index}.html"
+          File.open(File.join(tmp_path, filename), "w") do |f|
+            f.write(Bookshelf.render_template(chapter_template_path, :content => chapter.inner_html))
           end
 
-          FileUtils.mkdir_p(tmp_dir)
-
-          # Save file to disk.
-          #
-          File.open(section.filepath, "w") do |file|
-            body = section.html.css("body").to_xhtml.gsub(%r[<body>(.*?)</body>]m, "\\1")
-            file << render_chapter(body)
-          end
+          chapters << {
+            :text => chapter.css("h2:first-of-type").text,
+            :src => filename
+          }
         end
       end
 
-      def render_chapter(content)
-        locals = config.merge(:content => content)
-        render_template(template_path, locals)
+      def _create_toc_html
+        toc = chapters.map { |chapter|  [chapter[:text], chapter[:src]] }
+        File.open(File.join(tmp_path, "toc.html"), "w") do |f|
+          f.write(Bookshelf.render_template(toc_template_path, :toc => toc))
+        end
       end
 
-      def assets
-        @assets ||= begin
-          assets = Dir[Bookshelf.root_dir.join("output/assets/styles/epub.css")].map{|path| {path => "styles"}}
-          assets += Dir[Bookshelf.root_dir.join("output/assets/fonts/*.*")].map{|path| {path => "fonts"}}
-          assets += Dir[Bookshelf.root_dir.join("output/assets/images/*.{jpg,png,gif}")].map{|path| {path => "images"}}
-          assets
+      def _create_toc_ncx
+        # toc.ncx
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.doc.create_internal_subset(
+            "html",
+            "-//W3C//DTD XHTML 1.1//EN",
+            "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"
+          )
+          xml.ncx("xmlns" => "http://www.daisy.org/z3986/2005/ncx/", "version" => "2005-1") {
+            xml.head {
+              xml.meta("name" => "dtb:uid", "content" => config[:identifier][:id])
+              xml.meta("name" => "dtb:depth", "content" => "1")
+              xml.meta("name" => "dtb:totalPageCount", "content" => "0")
+              xml.meta("name" => "dtb:maxPageNumber", "content" => "0")
+            }
+            xml.docTitle {
+              xml.text_ config["title"]
+            }
+            xml.navMap {
+              chapters.each_with_index do |chapter, index|
+                xml.navPoint("id" => "navpoint-#{index}", "playOrder" => "#{index}") {
+                  xml.navLabel {
+                    xml.text_ chapter[:text]
+                  }
+                  xml.content("src" => chapter[:src])
+                }
+              end
+            }
+          }
+        end
+        File.open(File.join(tmp_path, "toc.ncx"), "w") do |f|
+          f.write builder.to_xml
         end
       end
 
-      def cover_image
-        path = Dir[book_dir.join("cover.{jpg,png,gif}").to_s].first
-        return path if path && File.exist?(path)
+      def _create_assets
+        base_assets = []
+        base_assets << asset_path.join("styles/epub.css").to_s
+        base_assets.concat( Dir[asset_path.join("fonts/*.*")])
+        base_assets.concat(Dir[asset_path.join("images/*.{jpg,png,gif}")])
+        base_assets.each do |base_asset|
+          asset = base_asset.sub("#{asset_path.to_s}/", "")
+          FileUtils.cp(base_asset, File.join(tmp_path, asset))
+          assets << asset
+        end
       end
 
-      def navigation
-        sections.map do |section|
-          {
-            :label => section.html.css("h2:first-of-type").text,
-            :content => section.filename
+      def _create_content_opf
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.package("xmlns" => "http://www.idpf.org/2007/opf", "unique-identifier" => config[:uid], "version" => 2.0 ) {
+            xml.metadata("xmlns:dc" => "http://purl.org/dc/elements/1.1/", "xmlns:dcterms" => "http://purl.org/dc/terms/", "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance", "xmlns:opf" => "http://www.idpf.org/2007/opf") {
+              xml["dc"].identifier config[:identifier][:id], {"opf:scheme" => config[:identifier][:type], "id" => config[:uid]}
+              xml["dc"].title config[:title]
+              xml["dc"].language config[:language]
+              xml["dc"].creator config[:authors].join(",")
+              xml["dc"].publisher config[:publisher]
+              xml["dc"].date config[:published_at]
+              xml.meta("name" => "cover", "content" => "cover")
+            }
+            xml.manifest {
+              chapters.each do |chapter|
+                xml.item("id" => chapter[:src], "href" => chapter[:src], "media-type" => "application/xhtml+xml")
+              end
+              assets.each do |asset|
+                id = asset.sub(/(styles|fonts|images)\//, "")
+                media_type = if asset.ends_with?("css")
+                  "text/css"
+                else
+                  ""
+                end
+                xml.item("id" => id, "href" => asset, "media-type" => media_type)
+              end
+              xml.item("id" => "cover", "href" => "cover.html", "media-type" => "application/xhtml+xml")
+              xml.item("id" => "toc", "href" => "toc.html", "media-type" => "application/xhtml+xml")
+              xml.item("id" => "ncx", "href" => "toc.ncx", "media-type" => "application/x-dtbncx+xml")
+            }
+            xml.spine("toc" => "ncx") {
+              xml.itemref("idref" => "cover")
+              xml.itemref("idref" => "toc")
+              chapters.each do |chapter|
+                xml.itemref("idref" => chapter[:src])
+              end
+            }
+            xml.guide {
+              xml.reference("type" => "toc", "title" => "Table of Contents", "href" => "toc.html")
+              if chapters.length > 0
+                xml.reference("type" => "text", "title" => chapters[0][:text], "href" => chapters[0][:src])
+              end
+            }
           }
         end
+        File.open(File.join(tmp_path, "content.opf"), "w") do |f|
+          f.write builder.to_xml
+        end
       end
 
-      def template_path
+      def _create_epub
+        require "zip"
+        # mimetype needs to be uncompressed
+        Zip::OutputStream::open(epub_path) do |os|
+          os.put_next_entry("mimetype", nil, nil, Zip::Entry::STORED, Zlib::NO_COMPRESSION)
+          os << "application/epub+zip"
+        end
+        zipfile = Zip::File.open(epub_path)
+        Dir.glob(File.join(tmp_path, "**/*")).each do |path|
+          zipfile.add(path.sub("#{tmp_path.to_s}/", ""), path )
+        end
+        zipfile.commit
+      end
+
+      def cover_template_path
+        Bookshelf.root_dir.join("templates/epub/cover.erb")
+      end
+
+      def toc_template_path
+        Bookshelf.root_dir.join("templates/epub/toc.erb")
+      end
+
+      def chapter_template_path
         Bookshelf.root_dir.join("templates/epub/page.erb")
       end
 
+      def asset_path
+        Bookshelf.root_dir.join("output/assets")
+      end
+
       def html_path
         Bookshelf.root_dir.join("output/#{name}.html")
       end
@@ -135,13 +212,9 @@ module Bookshelf
         Bookshelf.root_dir.join("output/#{name}.epub")
       end
 
-      def tmp_dir
+      def tmp_path
         Bookshelf.root_dir.join("output/tmp")
       end
-
-      def toc_path
-        tmp_dir.join("toc.html")
-      end
     end
   end
 end

data/lib/bookshelf/parser/html.rb

@@ -11,48 +11,46 @@ module Bookshelf
 
       # List of recognized extensions.
       #
-      EXTENSIONS = %w[md mkdn markdown textile html]
-
-      class << self
-        # The footnote index control. We have to manipulate footnotes
-        # because each chapter starts from 1, so we have duplicated references.
-        #
-        attr_accessor :footnote_index
-      end
+      EXTENSIONS = %w[md mkdn markdown html]
 
       # Parse all files and save the parsed content
       # to <tt>output/book_name.html</tt>.
       #
       def parse
-        reset_footnote_index!
-
         File.open(Bookshelf.root_dir.join("output/#{name}.html"), "w") do |file|
-          file << parse_layout(content)
+          locals = config.merge({
+            :content => content,
+            :toc => toc
+          })
+          file << Bookshelf.render_template(Bookshelf.root_dir.join("templates/html/layout.erb"), locals)
         end
         true
-      # rescue Exception
-      #   false
-      end
-
-      def reset_footnote_index!
-        self.class.footnote_index = 1
+      rescue Exception
+        false
       end
 
       # Return all chapters wrapped in a <tt>div.chapter</tt> tag.
       #
       def content
-        String.new.tap do |chapters|
+        @content ||= String.new.tap do |chapters|
           entries.each do |entry|
-            files = chapter_files(entry)
-
-            # no markup files, so skip to the next one!
-            next if files.empty?
+            chapters << %[<div class="chapter">#{render_file(entry)}</div>]
+          end
+        end
+      end
 
-            chapters << %[<div class="chapter">#{render_chapter(files)}</div>]
+      def toc
+        if @toc.blank?
+          @toc = ""
+          Nokogiri::HTML(content).css(".chapter h2:first-of-type").each do |xml|
+            @toc << %[<div><a href="##{xml.attribute("id")}"><span>#{CGI.escape_html(xml.text)}</span></a></div>]
           end
         end
+        return @toc
       end
 
+      private
+
       # Return a list of all recognized files.
       #
       def entries
@@ -62,27 +60,11 @@ module Bookshelf
         end
       end
 
-      private
-      def chapter_files(entry)
-        # Chapters can be files outside a directory.
-        if File.file?(entry)
-          [entry]
-        else
-          Dir.glob("#{entry}/**/*.{#{EXTENSIONS.join(",")}}").sort
-        end
-      end
-
       # Check if path is a valid entry.
-      # Files/directories that start with a dot or underscore will be skipped.
+      # Files that start with a dot or underscore will be skipped.
       #
       def valid_entry?(entry)
-        entry !~ /^(\.|_)/ && (valid_directory?(entry) || valid_file?(entry))
-      end
-
-      # Check if path is a valid directory.
-      #
-      def valid_directory?(entry)
-        File.directory?(book_dir.join(entry)) && !IGNORE_DIR.include?(File.basename(entry))
+        entry !~ /^(\.|_)/ && valid_file?(entry)
       end
 
       # Check if path is a valid file.
@@ -94,84 +76,25 @@ module Bookshelf
 
       # Render +file+ considering its extension.
       #
-      def render_file(file, plain_syntax = false)
+      def render_file(file)
         file_format = format(file)
-        content = Bookshelf::Syntax.render(book_dir, file_format, File.read(file), plain_syntax)
+        content = File.read(file)
         content = case file_format
         when :markdown
           Markdown.to_html(content)
-        when :textile
-          RedCloth.convert(content)
         else
           content
         end
-
-        render_footnotes(content, plain_syntax)
-      end
-
-      def render_footnotes(content, plain_syntax = false)
-        html = Nokogiri::HTML(content)
-        footnotes = html.css("p[id^='fn']")
-
-        return content if footnotes.empty?
-
-        reset_footnote_index! unless self.class.footnote_index
-
-        footnotes.each do |fn|
-          index = self.class.footnote_index
-          actual_index = fn["id"].gsub(/[^\d]/, "")
-
-          fn.set_attribute("id", "_fn#{index}")
-
-          html.css("a[href='#fn#{actual_index}']").each do |link|
-            link.set_attribute("href", "#_fn#{index}")
-          end
-
-          html.css("a[href='#fnr#{actual_index}']").each do |link|
-            link.set_attribute("href", "#_fnr#{index}")
-          end
-
-          html.css("[id=fnr#{actual_index}]").each do |tag|
-            tag.set_attribute("id", "_fnr#{index}")
-          end
-
-          self.class.footnote_index += 1
-        end
-
-        html.css("body").inner_html
       end
 
       def format(file)
         case File.extname(file).downcase
         when ".markdown", ".mkdn", ".md"
           :markdown
-        when ".textile"
-          :textile
         else
           :html
         end
       end
-
-      # Parse layout file, making available all configuration entries.
-      #
-      def parse_layout(html)
-        toc = TOC::HTML.generate(html)
-        locals = config.merge({
-          :content   => toc.content,
-          :toc       => toc.to_html
-        })
-        render_template(Bookshelf.root_dir.join("templates/html/layout.erb"), locals)
-      end
-
-      # Render all +files+ from a given chapter.
-      #
-      def render_chapter(files, plain_syntax = false)
-        String.new.tap do |chapter|
-          files.each do |file|
-            chapter << render_file(file, plain_syntax) << "\n\n"
-          end
-        end
-      end
     end
   end
 end