softcover 0.0.1 → 0.5.0

data/lib/softcover/builders/html.rb

@@ -0,0 +1,214 @@
+require 'fileutils'
+
+module Softcover
+  module Builders
+    class Html < Builder
+
+      def setup
+        Dir.mkdir "html" unless File.directory?("html")
+        unless File.directory?(path('html/stylesheets'))
+          Dir.mkdir path('html/stylesheets')
+        end
+        clean!
+      end
+
+      def build(options = {})
+        if Softcover::profiling?
+          require 'ruby-prof'
+          RubyProf.start
+        end
+
+        if manifest.markdown?
+          unless options[:'find-overfull']
+            FileUtils.rm(Dir.glob(path('chapters/*.tex')))
+          end
+          manifest.chapters.each do |chapter|
+            write_latex_files(chapter, options)
+          end
+          rewrite_master_latex_file
+          # Reset the manifest to use PolyTeX.
+          self.manifest = Softcover::BookManifest.new(source: :polytex,
+                                                      verify_paths: true)
+          @remove_tex = true unless options[:preserve_tex]
+        end
+
+        if manifest.polytex?
+          basename = File.basename(manifest.filename, '.tex')
+          @html  = converted_html(basename)
+          @title = basename
+          erb_file = File.read(File.join(File.dirname(__FILE__),
+                                         '../server/views/book.html.erb'))
+          file_content = ERB.new(erb_file).result(binding)
+          write_full_html_file(basename, file_content)
+          write_chapter_html_files(Nokogiri::HTML(file_content), erb_file)
+        end
+
+        if Softcover::profiling?
+          result = RubyProf.stop
+          printer = RubyProf::GraphPrinter.new(result)
+          printer.print(STDOUT, {})
+        end
+
+        remove_polytex! if remove_polytex?
+
+        true
+      end
+
+      # Writes the LaTeX files for a given Markdown chapter.
+      def write_latex_files(chapter, options = {})
+        path = File.join('chapters', chapter.slug + '.md')
+        cc = Softcover.custom_styles
+        md = Polytexnic::Pipeline.new(File.read(path), source: :md,
+                                                       custom_commands: cc)
+        filename = path("chapters/#{chapter.slug}.tex")
+        File.write(filename, md.polytex)
+      end
+
+      # Rewrites the master LaTeX file <name>.tex to use chapters from Book.txt.
+      def rewrite_master_latex_file
+        master_filename = Dir['*.tex'].reject { |f| f =~ /\.tmp/}.first
+        lines = File.readlines('Book.txt')
+        tex_file = []
+        lines.each do |line|
+          if line =~ /(.*)\.md\s*$/
+            tex_file << "\\include{chapters/#{$1}}"
+          elsif line =~ /(.*):\s*$/  # frontmatter or mainmatter
+            tex_file << "\\#{$1}"
+          elsif line.strip == 'cover'
+            tex_file << '\\includepdf{images/cover.pdf}'
+          else # raw command, like 'maketitle' or 'tableofcontents'
+            tex_file << "\\#{line.strip}"
+          end
+        end
+        tex_file << '\end{document}'
+        content = File.read(master_filename)
+        content.gsub!(/(\\begin{document}\n)(.*)/m) do
+          $1 + tex_file.join("\n") + "\n"
+        end
+        File.write(master_filename, content)
+      end
+
+      # Returns the converted HTML.
+      def converted_html(basename)
+        polytex_filename = basename + '.tex'
+        polytex = File.read(polytex_filename)
+        # Replace the includes with the file contents, padding with a trailing
+        # newline for safety.
+        polytex.gsub!(/(^\s*\\include{(.*?)})/) do
+          File.read($2 + '.tex') + "\n"
+        end
+        cc = Softcover.custom_styles
+        Polytexnic::Pipeline.new(polytex, custom_commands: cc).to_html
+      end
+
+      # Writes the full HTML file for the book.
+      # The resulting file is a self-contained HTML document suitable
+      # for viewing in isolation.
+      def write_full_html_file(basename, file_content)
+        html_filename = File.join('html', basename + '.html')
+        File.open(html_filename, 'w') do |f|
+          f.write(file_content)
+        end
+        polytexnic_css = File.join('html', 'stylesheets', 'softcover.css')
+        source_css     = File.join(File.dirname(__FILE__),
+                                   "../template/#{polytexnic_css}")
+        FileUtils.cp source_css, polytexnic_css
+        write_pygments_file(:html, File.join('html', 'stylesheets'))
+        built_files.push html_filename
+      end
+
+      # Writes the full HTML file for each chapter.
+      # The resulting files are self-contained HTML documents suitable
+      # for viewing in isolation.
+      def write_chapter_html_files(html, erb_file)
+        reference_cache = split_into_chapters(html)
+        target_cache = build_target_cache(html)
+        manifest.chapters.each_with_index do |chapter, i|
+          update_cross_references(chapter, reference_cache, target_cache)
+          write_fragment_file(chapter)
+          write_complete_file(chapter, erb_file, i)
+        end
+      end
+
+      # Splits the full XML document into chapters.
+      def split_into_chapters(xml)
+        chapter_number = 0
+        current_chapter = manifest.chapters.first
+        reference_cache = {}
+        xml.css('#book>div').each do |node|
+          klass = node.attributes['class'].to_s
+          id = node.attributes['id'].to_s
+          if klass == 'chapter' || id == 'frontmatter'
+            current_chapter = manifest.chapters[chapter_number]
+            node['data-chapter'] = current_chapter.slug
+            chapter_number += 1
+          end
+
+          reference_cache[node['data-tralics-id']] = current_chapter
+          node.xpath('.//*[@data-tralics-id]').each do |labeled_node|
+            reference_cache[labeled_node['data-tralics-id']] = current_chapter
+          end
+
+          current_chapter.nodes.push node
+        end
+        reference_cache
+      end
+
+      # Builds a cache of targets for cross-references.
+      def build_target_cache(xml)
+        {}.tap do |target_cache|
+          xml.xpath("//*[@id]").each do |target|
+            target_cache[target['id']] = target
+          end
+        end
+      end
+
+      # Updates the book's cross-references.
+      def update_cross_references(chapter, ref_map, target_cache)
+        chapter.nodes.each do |node|
+          node.css('a.hyperref').each do |ref_node|
+            ref_id = ref_node['href'][1..-1]  # i.e., 'cha-foo_bar'
+            target = target_cache[ref_id]
+            unless target.nil?
+              id = target['id']
+              ref_chapter = ref_map[target['data-tralics-id']]
+              ref_node['href'] = "#{ref_chapter.fragment_name}##{id}"
+            end
+          end
+        end
+      end
+
+      # Writes the chapter fragment HTML (omitting, e.g., <html> tags, etc.)
+      def write_fragment_file(chapter)
+        html_filename = File.join('html', "#{chapter.slug}_fragment.html")
+        File.open(html_filename, 'w') do |f|
+          chapter.nodes.each do |node|
+            f.write(node.to_xhtml)
+          end
+        end
+        built_files.push html_filename
+      end
+
+      # Writes the chapter as a complete, self-contained HTML document.
+      def write_complete_file(chapter, erb_file, n)
+        html_filename = File.join('html', chapter.slug + '.html')
+        File.open(html_filename, 'w') do |f|
+          @html = chapter.nodes.map(&:to_xhtml).join("\n")
+          @mathjax = Softcover::Mathjax::config(chapter_number: n)
+          @src     = Softcover::Mathjax::AMS_SVG
+          file_content = ERB.new(erb_file).result(binding)
+          f.write(file_content)
+        end
+        built_files.push html_filename
+      end
+
+      def clean!
+        # It's safe to remove HTML files in the html/ directory,
+        # as they are regenerated every time the book gets built.
+        # This also arranges to clear out unused HTML files, as happens when,
+        # e.g., the name of a LaTeX chapter file changes.
+        FileUtils.rm(Dir.glob(path('html/*.html')))
+      end
+    end
+  end
+end

data/lib/softcover/builders/mobi.rb

@@ -0,0 +1,30 @@
+module Softcover
+  module Builders
+    class Mobi < Builder
+
+      def build!(options={})
+        Softcover::Builders::Epub.new.build!(options)
+        filename  = manifest.filename
+        filename += '-preview' if options[:preview]
+        command = "#{kindlegen} ebooks/#{filename}.epub"
+        # Because of the way kindlegen uses tempfiles, testing for the
+        # actual generation of the MOBI causes an error, so in tests
+        # we just return the command.
+        if options[:quiet] || options[:silent]
+          silence { Softcover.test? ? command : system(command) }
+        else
+          Softcover.test? ? command : system(command)
+        end
+      end
+
+      private
+
+        def kindlegen
+          filename = `which kindlegen`.chomp
+          url = 'http://www.amazon.com/gp/feature.html?ie=UTF8&docId=1000765211'
+          message  = "Install kindlegen (#{url})"
+          @kindlegen ||= executable(filename, message)
+        end
+    end
+  end
+end

data/lib/softcover/builders/pdf.rb

@@ -0,0 +1,110 @@
+module Softcover
+  module Builders
+    class Pdf < Builder
+      include Softcover::Output
+
+      def build!(options={})
+        if manifest.markdown?
+          # Build the HTML to produce PolyTeX as a side-effect,
+          # then update the manifest to reduce PDF generation
+          # to a previously solved problem.
+          Softcover::Builders::Html.new.build!(options.merge(preserve_tex:
+                                                              true))
+          self.manifest = Softcover::BookManifest.new(source: :polytex)
+          @remove_tex = true unless options[:preserve_tex]
+        end
+        # Build the PolyTeX filename so it accepts both 'foo' and 'foo.tex'.
+        basename = File.basename(@manifest.filename, '.tex')
+        book_filename = basename + '.tex'
+
+        # In debug mode, execute `xelatex` and exit.
+        if options[:debug]
+          execute "#{xelatex} #{book_filename}"
+          return    # only gets called in test env
+        elsif options[:'find-overfull']
+          tmp_name = book_filename.sub('.tex', '.tmp.tex')
+          # The we do things, code listings show up as "Overfull", but they're
+          # actually fine, so filter them out.
+          filter_out_listings = "grep -v 3.22281pt"
+          # It's hard to correlate Overfull line numbers with source files,
+          # so we use grep's -A flag to provide some context instead. Authors
+          # can then use their text editors to find the corresponding place
+          # in the text.
+          show_context = 'grep -A 3 "Overfull \hbox"'
+          cmd = "xelatex #{tmp_name} | #{filter_out_listings} | #{show_context}"
+          execute cmd
+          return
+        end
+
+        polytex_filenames = @manifest.chapter_file_paths << book_filename
+        polytex_filenames.delete(path('chapters/frontmatter.tex'))
+        polytex_filenames.each do |filename|
+          puts filename unless options[:quiet] || options[:silent]
+          polytex = File.open(filename) { |f| f.read }
+          latex   = Polytexnic::Pipeline.new(polytex).to_latex
+          if filename == book_filename
+            latex.gsub!(/\\include{(.*?)}/) do
+              "\\include{#{Softcover::Utils.tmpify($1)}.tmp}"
+            end
+          end
+          File.open(Softcover::Utils.tmpify(filename), 'w') do |f|
+            f.write(latex)
+          end
+        end
+        write_pygments_file(:latex)
+        copy_polytexnic_sty
+
+        remove_polytex! if remove_polytex?
+
+        build_pdf = "#{xelatex} #{Softcover::Utils.tmpify(book_filename)}"
+        # Run the command twice (to guarantee up-to-date cross-references)
+        # unless explicitly overriden.
+        # Renaming the PDF in the command is necessary because `execute`
+        # below uses `exec` (except in tests, where it breaks). Since `exec`
+        # causes the Ruby process to end, any Ruby code after `exec`
+        # is ignored.
+        # (The reason for using `exec` is so that LaTeX errors get emitted to
+        # the screen rather than just hanging the process.)
+        pdf_cmd = options[:once] ? build_pdf : "#{build_pdf} ; #{build_pdf}"
+        cmd = "#{pdf_cmd} ; #{rename_pdf(basename)}"
+        # Here we use `system` when making a preview because the preview command
+        # needs to run after the main PDF build.
+        if options[:quiet] || options[:silent]
+          silence { options[:preview] ? system(cmd) : execute(cmd) }
+        else
+          options[:preview] ? system(cmd) : execute(cmd)
+        end
+      end
+
+      private
+
+        # Returns the `xelatex` executable.
+        # The `xelatex` program is roughly equivalent to the more standard
+        # `pdflatex`, but has better support for Unicode.
+        def xelatex
+          filename = `which xelatex`.chomp
+          message  = "Install LaTeX (http://latex-project.org/ftp.html)"
+          @xelatex ||= executable(filename, message)
+        end
+
+        # Returns the command to rename the temp PDF.
+        # The purpose is to match the original filename.
+        # For example, foo_bar.tex should produce foo_bar.pdf.
+        # While we're at it, we move it to the standard ebooks/ directory.
+        def rename_pdf(basename)
+          tmp_pdf = basename + '.tmp.pdf'
+          pdf     = basename + '.pdf'
+          mkdir('ebooks')
+          "mv -f #{tmp_pdf} #{File.join('ebooks', pdf)}"
+        end
+
+        # Copies the PolyTeXnic style file to ensure it's always fresh.
+        def copy_polytexnic_sty
+          polytexnic_sty = 'softcover.sty'
+          source_sty     = File.join(File.dirname(__FILE__),
+                                     "../template/#{polytexnic_sty}")
+          FileUtils.cp source_sty, polytexnic_sty
+        end
+    end
+  end
+end

data/lib/softcover/builders/preview.rb

@@ -0,0 +1,34 @@
+module Softcover
+  module Builders
+    class Preview < Builder
+
+      def build!
+        # Recall that MOBI generation makes an EPUB as a side-effect.
+        Softcover::Builders::Mobi.new.build!(preview: true)
+        Softcover::Builders::Pdf.new.build!(preview: true)
+        extract_pdf_pages
+      end
+
+      private
+
+        # Extracts pages from the PDF using GhostScript.
+        # The page range is set by the `pdf_preview_page_range` parameter
+        # in book.yml so that authors can override the default range.
+        def extract_pdf_pages
+          input  = File.join('ebooks', manifest.filename + '.pdf')
+          output = input.sub('.pdf', '-preview.pdf')
+          range  = manifest.pdf_preview_page_range.split('..').map(&:to_i)
+          cmd  = %(yes | #{ghostscript} -dBATCH -sOutputFile="#{output}")
+          cmd += %( -dFirstPage=#{range.first} -dLastPage=#{range.last})
+          cmd += %( -sDEVICE=pdfwrite "#{input}" >& /dev/null)
+          execute cmd
+        end
+
+        def ghostscript
+          filename = `which gs`.chomp
+          message  = "Install GhostScript (should come with LaTeX)"
+          @ghostscript ||= executable(filename, message)
+        end
+    end
+  end
+end

data/lib/softcover/builders/utils/page.js

@@ -0,0 +1,62 @@
+// Processes an HTML page, including any MathJax math typesetting.
+// Output is written to the file `phantomjs_source.html`.
+
+var system = require('system');
+var fs = require('fs');
+var page = require('webpage').create();
+
+page.open(system.args[1], function (status) {
+    if (status !== "success") {
+      console.log("Unable to access network");
+    } else {
+      //
+      //  This gets called when MathJax is done
+      //
+      page.onAlert = function (msg) {
+        if (msg === "MathJax Done") {
+          var html = page.evaluate(function(){
+            var hiddenDiv = document.getElementById('MathJax_SVG_Hidden');
+            var svgs = document.getElementsByTagName('svg');
+            var origDefs = hiddenDiv.nextSibling.firstChild;
+            for (var i = 1; i < svgs.length; ++i)  {
+              var defs = origDefs.cloneNode(false);
+              var svg = svgs[i];
+              // append shallow defs and change xmlns.
+              svg.insertBefore(defs, svg.firstChild);
+              svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+              // clone and copy all used paths into local defs.
+              var uses = svg.getElementsByTagName("use");
+              for (var k = 0; k < uses.length; ++k) {
+                var id = uses[k].getAttribute("href");
+                defs.appendChild(
+                  document.getElementById(id.substr(1)).cloneNode(true)
+                );
+                uses[k].setAttribute("xlink:href", id);
+              }
+              svg.style.position = "static";
+            }
+            svg_defs = document.getElementsByTagName('div')[0];
+            svg_defs.parentNode.removeChild(svg_defs);
+            return document.body.innerHTML;
+          });
+
+          utf8 = '<meta http-equiv="Content-type" content="text/html; charset=utf-8">'
+          fs.write('phantomjs_source.html', utf8 + html, 'w');
+          phantom.exit();
+        } else if (msg === "MathJax Timeout") {
+            console.log("Timed out waiting for MathJax");
+            phantom.exit();
+        } else { console.log(msg) }
+      }
+    }
+
+    page.evaluate(function () {
+      var script = document.createElement("script");
+      script.type = "text/x-mathjax-config";
+      script.text = "MathJax.Hub.Queue([alert,'MathJax Done'])";
+      document.head.appendChild(script);
+      // Time out after 60 seconds, which should be long enough for
+      // almost all documents.
+      setTimeout(function () { alert("MathJax Timeout") }, 60000);
+    });
+});