git-scribe-qp 0.1.1

data/javascripts/toc.js

@@ -0,0 +1,77 @@
+/*
+ * IMPORTANT:
+ * This file (toc.js is) deprecated (superceded by asciidoc-xhtml11.js in
+ * AsciiDoc 8.5.1.  toc.js is retained for compatibility with user customised
+ * (pre 8.5.1) xhtml11 [header] and [footer] sections.
+ *
+ */
+
+/* Author: Mihai Bazon, September 2002
+ * http://students.infoiasi.ro/~mishoo
+ *
+ * Table Of Content generator
+ * Version: 0.4
+ *
+ * Feel free to use this script under the terms of the GNU General Public
+ * License, as long as you do not remove or alter this notice.
+ */
+
+ /* modified by Troy D. Hanson, September 2006. License: GPL */
+ /* modified by Stuart Rackham, October 2006. License: GPL */
+
+function getText(el) {
+  var text = "";
+  for (var i = el.firstChild; i != null; i = i.nextSibling) {
+    if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
+      text += i.data;
+    else if (i.firstChild != null)
+      text += getText(i);
+  }
+  return text;
+}
+
+function TocEntry(el, text, toclevel) {
+  this.element = el;
+  this.text = text;
+  this.toclevel = toclevel;
+}
+
+function tocEntries(el, toclevels) {
+  var result = new Array;
+  var re = new RegExp('[hH]([2-'+(toclevels+1)+'])');
+  // Function that scans the DOM tree for header elements (the DOM2
+  // nodeIterator API would be a better technique but not supported by all
+  // browsers).
+  var iterate = function (el) {
+    for (var i = el.firstChild; i != null; i = i.nextSibling) {
+      if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
+        var mo = re.exec(i.tagName)
+        if (mo)
+          result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
+        iterate(i);
+      }
+    }
+  }
+  iterate(el);
+  return result;
+}
+
+// This function does the work. toclevels = 1..4.
+function generateToc(toclevels) {
+  var toc = document.getElementById("toc");
+  var entries = tocEntries(document.getElementsByTagName("body")[0], toclevels);
+  for (var i = 0; i < entries.length; ++i) {
+    var entry = entries[i];
+    if (entry.element.id == "")
+      entry.element.id = "toc" + i;
+    var a = document.createElement("a");
+    a.href = "#" + entry.element.id;
+    a.appendChild(document.createTextNode(entry.text));
+    var div = document.createElement("div");
+    div.appendChild(a);
+    div.className = "toclevel" + entry.toclevel;
+    toc.appendChild(div);
+  }
+  if (entries.length == 0)
+    document.getElementById("header").removeChild(toc);
+}

data/lib/decorator.rb

@@ -0,0 +1,98 @@
+require 'open3'
+
+class Decorator
+  def initialize
+    @dir = Dir.pwd
+    @docbook = "#{@dir}/output/book.xml"
+    @fop = "#{@dir}/output/book.fo"
+  end
+
+  def docbook
+    xml = File.read(@docbook)
+
+    xml.gsub!(
+      /<programlisting(.+?)language="(\w+)"(.*?)>(.+?)<\/programlisting>/m
+    ) { |m|
+        %Q|<programlisting#{$1}language="#{$2}"#{$3}>| +
+          %Q|//:::#{$2}:::\n#{$4}| +
+        %Q|</programlisting>|
+      }
+
+    # File.write("#{@docbook}.tmp", xml)
+    File.write(@docbook, xml)
+  end
+
+  # TODO better regexp. Mono font?
+  def fop
+    xml = File.read(@fop)
+
+    xml.gsub!(
+      /<fo:block(.+?)>\/\/:::(\w+):::\n(.+?)(<\/fo:block>)/m
+    ) { |m|
+
+        language = $2
+        code = $3
+
+        %Q|<fo:block#{$1}>| +
+          highlight_fo(code, language) +
+        %Q|#{$4}|
+      }
+
+    File.write("#{@fop}", xml)
+  end
+
+
+  private
+  def highlight_fo(code, language)
+    # $stderr.puts "****************"
+    # $stderr.puts "**** #{language}"
+    # $stderr.puts code
+
+    # Don't highlight code with callouts
+    return code if (code =~ /<fo:inline/)
+
+    convert_bb_to_fo(
+      bb_pygments(code, language)
+    )
+  end
+
+  def bb_pygments(code, language)
+    cmd = "pygmentize -O style=borland -f bb -l #{language}"
+
+    code = CGI::unescapeHTML(code) if language == "html"
+
+    output = ''
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      stdin.write(code)
+      stdin.close_write
+
+      output = stdout.read #.tap{|bb| $stderr.puts bb}
+    end
+
+    return CGI::escapeHTML(output) if language == "html"
+    output
+  end
+
+  def convert_bb_to_fo(bb)
+    # $stderr.puts "----------"
+
+    bb.gsub(
+      /\[color=([^\]]+)\]\[i\](.+?)\[\/i\]\[\/color\]/m,
+      '<fo:inline font-style="italic" color="\1">\2</fo:inline>'
+    ).gsub(
+      /\[color=([^\]]+)\]\[b\](.+?)\[\/b\]\[\/color\]/m,
+      '<fo:inline font-weight="bold" color="\1">\2</fo:inline>'
+    ).gsub(
+      /\[i\](.+?)\[\/i\]/m,
+      '<fo:inline font-style="italic">\1</fo:inline>'
+    ).gsub(
+      /\[b\](.+?)\[\/b\]/m,
+      '<fo:inline font-weight="bold">\1</fo:inline>'
+    ).gsub(
+      /\[color=([^\]]+)\](.+?)\[\/color\]/m,
+      '<fo:inline color="\1">\2</fo:inline>'
+    )
+
+    # .tap{|fo| $stderr.puts fo }
+  end
+end

data/lib/git-scribe.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'nokogiri'
+require 'liquid'
+require 'yaml'
+require 'grit'
+
+require 'git-scribe/generate'
+require 'git-scribe/check'
+require 'git-scribe/init'
+require 'decorator'
+
+require 'fileutils'
+require 'pp'
+
+class GitScribe
+
+  include Init
+  include Check
+  include Generate
+
+  attr_accessor :subcommand, :args, :options
+  attr_reader :info
+
+  BOOK_FILE = 'book.asc'
+  OUTPUT_TYPES = ['docbook', 'html', 'pdf', 'epub', 'mobi', 'site', 'ebook']
+  SCRIBE_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+  def initialize
+    @subcommand = nil
+    @args = []
+    @options = {}
+    @config = YAML::parse(File.open(local('.gitscribe'))).transform rescue {}
+    @decorate = Decorator.new
+  end
+
+  ## COMMANDS ##
+
+  def die(message)
+    raise message
+  end
+
+  def local(file)
+    File.expand_path(File.join(Dir.pwd, file))
+  end
+
+  def base(file)
+    File.join(SCRIBE_ROOT, file)
+  end
+
+  # API/DATA HELPER FUNCTIONS #
+
+  def git(subcommand)
+    `git #{subcommand}`.chomp
+  end
+
+  def first_arg(args)
+    Array(args).shift
+  end
+
+  # eventually we'll want to log this or have it retrievable elsehow
+  def info(message)
+    @info ||= []
+    @info << message
+  end
+
+end

data/lib/git-scribe/check.rb

@@ -0,0 +1,71 @@
+class GitScribe
+  module Check
+    # check that we have everything needed
+    def check(args = [])
+      status = {}
+
+      # check for asciidoc
+      if !check_can_run('asciidoc')
+        info "asciidoc is not present, please install it for anything to work"
+        status[:asciidoc] = false
+      else
+        info "asciidoc - ok"
+        status[:asciidoc] = true
+      end
+
+      # check for xsltproc
+      if !check_can_run('xsltproc --version')
+        info "xsltproc is not present, please install it for html generation"
+        status[:xsltproc] = false
+      else
+        info "xsltproc - ok"
+        status[:xsltproc] = true
+      end
+
+      # check for a2x - should be installed with asciidoc, but you never know
+      if !check_can_run('a2x')
+        info "a2x is not present, please install it for epub generation"
+        status[:a2x] = false
+      else
+        info "a2x      - ok"
+        status[:a2x] = true
+      end
+
+      # check for source-highlight
+      if !check_can_run('source-highlight --version')
+        info "source-highlight is not present, please install it for source code highlighting"
+        status[:highlight] = false
+      else
+        info "highlighting - ok"
+        status[:highlight] = true
+      end
+
+
+      # check for fop
+      if !check_can_run('fop -v -out list')
+        info "fop is not present, please install for PDF generation"
+        status[:fop] = false
+      else
+        info "fop      - ok"
+        status[:fop] = true
+      end
+
+      # check for kindlegen
+      if !check_can_run('kindlegen')
+        info "kindlegen is not present, please install for mobi generation"
+        status[:mobi] = false
+      else
+        info "kindlegen - ok"
+        status[:mobi] = true
+      end
+
+
+      status
+    end
+
+    def check_can_run(command)
+      `#{command} 2>&1`
+      $?.success?
+    end
+  end
+end

data/lib/git-scribe/cli.rb

@@ -0,0 +1,84 @@
+require 'subcommand'
+
+class GitScribe
+  include Subcommands
+
+  def info(message)
+    puts message
+  end
+
+  module CLI
+
+    def run
+      parse_options
+      if @subcommand && self.respond_to?(@subcommand)
+        begin
+          self.send @subcommand, @args
+        rescue Object => e
+          error e
+        end
+      else
+        help
+      end
+    end
+
+    def error(e)
+      puts 'Error: ' + e.to_s
+    end
+
+    def help
+      puts print_actions
+    end
+
+    def parse_options
+      @options = {}
+      global_options do |opts|
+        opts.banner = "Usage: #{$0} [options] [subcommand [options]]"
+        opts.description = "git-scribe helps you write books with the power of Git"
+        opts.separator ""
+        opts.separator "Global options are:"
+        opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          @options[:verbose] = v
+        end
+      end
+
+      command :init do |opts|
+        opts.banner = "Usage: git scribe init (directory)"
+        opts.description = "initialize a new book layout"
+        opts.on("-l", "--lang", "choose a default language (en)") do |v|
+          @options[:lang] = lang || 'en'
+        end
+      end
+
+      command :gen do |opts|
+        opts.banner = "Usage: git scribe gen [options]"
+        opts.description = "generate digital formats"
+      end
+
+      command :check do |opts|
+        opts.banner = "Usage: git scribe check"
+        opts.description = "checks for system requirements for doc generation"
+      end
+
+      @subcommand = opt_parse
+      @args = ARGV
+    end
+
+    # DISPLAY HELPER FUNCTIONS #
+
+    def l(info, size)
+      clean(info)[0, size].ljust(size)
+    end
+
+    def r(info, size)
+      clean(info)[0, size].rjust(size)
+    end
+
+    def clean(info)
+      info.to_s.gsub("\n", ' ')
+    end
+
+  end
+
+  include CLI
+end

data/lib/git-scribe/generate.rb

@@ -0,0 +1,473 @@
+class GitScribe
+  module Generate
+    # generate the new media
+    def gen(args = [])
+      @done = {}  # what we've generated already
+      @remove_when_done = []
+      @wd = Dir.getwd
+
+      type = first_arg(args) || 'all'
+      prepare_output_dir
+
+      types = type == 'all' ? OUTPUT_TYPES : [type]
+
+      ret = false
+      output = []
+      Dir.chdir("output") do
+        types.each do |out_type|
+          call = 'do_' + out_type
+          if self.respond_to? call
+            ret = self.send call
+          else
+            die "NOT A THING: #{call}"
+          end
+        end
+        clean_up
+        ret
+      end
+    end
+
+    def do_docbook
+      return true if @done['docbook']
+      info "GENERATING DOCBOOK"
+
+      if ex("asciidoc -b docbook --doctype book -v #{BOOK_FILE}")
+        @done['docbook'] = true
+        'book.xml'
+      end
+    end
+
+    def do_pdf
+      return true if @done['pdf']
+
+      info "GENERATING PDF"
+      do_docbook
+
+      @decorate.docbook
+
+      # TODO: start chapters on the recto page
+      # (initial.page.number=auto-odd? break.before=page-even?)
+      strparams = {
+        'callout.graphics' => 1,
+        'navig.graphics' => 1,
+        'admon.textlabel' => 1,
+        'admon.graphics' => 1,
+        #'page.width' => '7.5in',
+        #'page.height' => '9in',
+        'body.font.family' => "'WenQuanYi Zen Hei'",
+        'title.font.family' => "'WenQuanYi Micro Hei'",
+        'monospace.font.family' => "'Liberation Mono'"
+      }
+      param = strparams.map { |k, v| "--stringparam #{k} #{v}" }.join(' ')
+      cmd = "xsltproc  --nonet #{param} --output #{local('book.fo')} #{base('docbook-xsl/fo.xsl')} #{local('book.xml')}"
+      ex(cmd)
+
+      @decorate.fop
+
+      cmd = "fop -c #{base('docbook-xsl/fop.xconf')} -fo #{local('book.fo')} -pdf #{local('book.pdf')}"
+      ex(cmd)
+
+      return false unless $?.exitstatus == 0
+      @done['pdf'] = true
+    end
+
+    def do_epub
+      return true if @done['epub']
+
+      info "GENERATING EPUB"
+
+      generate_docinfo
+      # TODO: look for custom stylesheets
+      cmd = "#{a2x_wss('epub')} -a docinfo -k -v #{BOOK_FILE}"
+      return false unless ex(cmd)
+
+      @done['epub'] = true
+    end
+
+    def do_mobi
+      return true if @done['mobi']
+
+      do_epub
+
+      info "GENERATING MOBI"
+
+      decorate_epub_for_mobi
+
+      cmd = "kindlegen -verbose book_for_mobi.epub -o book.mobi"
+      return false unless ex(cmd)
+
+      cmd = @wd +  '/scripts/post-mobi.sh'
+      if File.exists?(cmd) && File.executable?(cmd)
+        return false unless ex(cmd)
+      end
+
+      @done['mobi'] = true
+    end
+
+    def do_ebook
+      do_pdf
+      do_epub
+      do_mobi
+      zip_ebook
+    end
+
+    def do_html
+      return true if @done['html']
+      info "GENERATING HTML"
+
+      # TODO: look for custom stylesheets
+      cmd = "asciidoc -a scriptsdir='javascripts' -a linkcss -a stylesdir='stylesheets' -a theme=scribe #{BOOK_FILE}"
+      return false unless ex(cmd)
+
+      @done['html'] = true
+    end
+
+    def do_site
+      info "GENERATING SITE"
+
+      prepare_output_dir("site")
+      Dir.chdir("site") do
+        ex("asciidoc -b docbook #{BOOK_FILE}")
+        xsldir = base('docbook-xsl/xhtml')
+        ex("xsltproc --stringparam html.stylesheet stylesheets/scribe.css --nonet #{xsldir}/chunk.xsl book.xml")
+
+        clean_site
+      end
+    end
+
+    private
+    def prepare_output_dir(dir='output')
+      FileUtils.mkdir_p(dir)
+      FileUtils.cp_r "#{@wd}/book/.", dir, :remove_destination => true
+
+      FileUtils.mkdir_p("#{dir}/stylesheets")
+      FileUtils.cp_r File.join(SCRIBE_ROOT, 'stylesheets'), dir
+
+      FileUtils.mkdir_p("#{dir}/javascripts")
+      FileUtils.cp_r File.join(SCRIBE_ROOT, 'javascripts'), dir
+
+      FileUtils.mkdir_p("#{dir}/images/icons")
+      FileUtils.cp_r File.join(SCRIBE_ROOT, 'icons'),
+                     "#{dir}/images"
+    end
+
+    def clean_up
+      FileUtils.rm Dir.glob('**/*.asc')
+      FileUtils.rm_r @remove_when_done
+    end
+
+    def ex(command)
+      out = `#{command} 2>&1`
+      info out
+      $?.exitstatus == 0
+    end
+
+    def generate_docinfo
+      docinfo_template = liquid_template('book-docinfo.xml')
+      File.open('book-docinfo.xml', 'w+') do |f|
+        cover  = @config['cover'] || 'images/cover.jpg'
+        data = {'title'       => book_title,
+                'cover_image' => cover}
+        f.puts docinfo_template.render( data )
+      end
+    end
+
+    def a2x_wss(type)
+      a2x(type) + " --stylesheet=stylesheets/scribe.css"
+    end
+
+    def a2x(type)
+      "a2x -f #{type} -d book "
+    end
+
+    def decorate_epub_for_mobi
+      add_epub_etype
+      add_epub_toc
+      flatten_ncx
+      clean_epub_html
+      clean_epub_css
+      zip_epub_for_mobi
+    end
+
+    def add_epub_etype
+      Dir.chdir('book.epub.d') do
+        FileUtils.cp 'mimetype', 'etype'
+      end
+    end
+
+    def add_epub_toc
+      build_html_toc
+      add_html_toc_to_opf
+    end
+
+    def build_html_toc
+      Dir.chdir('book.epub.d/OEBPS') do
+        ncx = File.read('toc.ncx')
+        titles = ncx.scan(%r{^          <ncx:text>(.+?)</ncx:text>}m).flatten
+        urls = ncx.scan(%r{^        <ncx:content src="(.+?)"/>}m).flatten
+
+        titles_and_urls = titles.zip(urls).reject { |entry|
+          entry[1].match(/^pr\d+.html$/) &&
+          !entry[0].match(/introduction/i)
+        }
+
+        File.open("toc.html", 'w') do |f|
+          f.puts('<?xml version="1.0" encoding="UTF-8"?>')
+          f.puts('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head><title>Table of Contents</title></head><body>')
+          titles_and_urls.each do |entry|
+            f.puts <<_EOM
+<div>
+<span class="chapter">
+<a href="#{entry[1]}">#{entry[0]}</a>
+</span>
+</div>
+_EOM
+          end
+          f.puts('</body></html>')
+        end
+      end
+    end
+
+    def add_html_toc_to_opf
+      Dir.chdir('book.epub.d/OEBPS') do
+        opf = File.read('content.opf')
+        opf = add_html_toc_to_opf_manifest(opf)
+        opf = add_html_toc_to_opf_spine(opf)
+        opf = add_html_toc_to_opf_guide(opf)
+        File.open('content.opf', 'w') do |f|
+          f.puts opf
+        end
+      end
+    end
+
+    def add_html_toc_to_opf_manifest(opf)
+      opf.sub(/<item[^>]+id="ncxtoc".+?>/) { |s|
+        s + "\n" +
+          %q|    <item id="htmltoc" | +
+                    %q|media-type="application/xhtml+xml" | +
+                    %q|href="toc.html"/>| }
+    end
+    def add_html_toc_to_opf_spine(opf)
+      opf.sub(/<itemref idref="cover".+?>/) { |s|
+        s + "\n" +
+          %q|    <itemref idref="htmltoc" linear="no"/>| }
+    end
+    def add_html_toc_to_opf_guide(opf)
+      opf.sub(/<\/guide>/) { |s|
+        "  " +
+        %q|<reference href="toc.html" type="toc" title="Table of Contents"/>| +
+        "\n  " +
+        s }
+    end
+
+    def flatten_ncx
+      nav_points = ncx_nav_points.map { |x| x.gsub(/^\s+/, '') }
+
+      Dir.chdir('book.epub.d/OEBPS') do
+        ncx = File.read('toc.ncx')
+
+        File.open("toc.ncx", 'w') do |f|
+          f.write ncx.sub(
+            /<ncx:navMap>.+<\/ncx:navMap>/m,
+            "<ncx:navMap>\n#{nav_points.join("\n")}\n</ncx:navMap>"
+          )
+        end
+      end
+    end
+
+    def ncx_nav_points
+      nav_points = []
+
+      Dir.chdir('book.epub.d/OEBPS') do
+        nav_points = File.read('toc.ncx').
+          scan(%r{<ncx:navPoint.+?<ncx:content src=.+?/>}m)
+      end
+
+      nav_points.
+        flatten.
+        map { |x| x + "\n</ncx:navPoint>" }
+    end
+
+    def clean_epub_html
+      Dir.glob('book.epub.d/OEBPS/*.html').
+        each { |file| clean_html(file) }
+    end
+
+    def clean_html(file)
+      content = File.read(file)
+      File.open(file, 'w') do |f|
+        f.write content.
+          gsub(%r"<li(.*?)>\s*(.+?)\s*</li>"m, '<li\1>\2</li>').
+          gsub(%r"<li(.*?)>\s+(.+?)\s*</li>"m, '<li\1>\2</li>').
+          gsub(%r'<h([123] class="title".*?)><a (id=".+?")[></a]+>'m, '<h\1 \2>')
+      end
+    end
+
+    def clean_epub_css
+      Dir.chdir('book.epub.d/OEBPS/stylesheets') do
+        content = File.read('scribe.css')
+        File.open('scribe.css', 'w') do |f|
+          f.write content.sub(/^pre[^}]+/m) { |s|
+            s + "  font-size: 8px;\n"
+          }
+        end
+      end
+    end
+
+    def zip_epub_for_mobi
+      @remove_when_done <<
+        'book.epub.d' <<
+        'book_for_mobi.epub'
+
+      Dir.chdir('book.epub.d') do
+        ex("zip ../book_for_mobi.epub . -r")
+      end
+    end
+
+    def zip_ebook
+      file_name = book_title.downcase.gsub(/\s+/, '_')
+
+      Dir.mkdir(file_name) rescue nil
+      FileUtils.cp 'book.pdf', "#{file_name}/#{file_name}.pdf"
+      FileUtils.cp 'book.epub', "#{file_name}/#{file_name}.epub"
+      FileUtils.cp 'book.mobi', "#{file_name}/#{file_name}.mobi"
+
+      ex("zip #{file_name}.zip #{file_name} -r")
+    end
+
+    def book_title
+      do_html
+
+      source = File.read("book.html")
+      t = /\<title>(.*?)<\/title\>/.match(source)
+
+      t ? t[1] : 'Title'
+    end
+
+    def clean_site
+      source = File.read('index.html')
+      html = Nokogiri::HTML.parse(source, nil, 'utf-8')
+
+      sections = []
+      c = -1
+
+      # each chapter
+      html.css('.toc > dl').each do |section|
+        section.children.each do |item|
+          if item.name == 'dt' # section
+            c += 1
+            sections[c] ||= {'number' => c}
+            link = item.css('a').first
+            sections[c]['title'] = title = link.text
+            sections[c]['href'] = href = link['href']
+            clean_title = title.downcase.gsub(/[^a-z0-9\-_]+/, '_') + '.html'
+            sections[c]['link'] = clean_title
+            if href[0, 10] == 'index.html'
+              sections[c]['link'] = 'title.html'
+            end
+            sections[c]['sub'] = []
+          end
+          if item.name == 'dd' # subsection
+            item.css('dt').each do |sub|
+              link = sub.css('a').first
+              data = {}
+              data['title'] = title = link.text
+              data['href'] = href = link['href']
+              data['link'] = sections[c]['link'] + '#' + href.split('#').last
+              sections[c]['sub'] << data
+            end
+          end
+        end
+      end
+
+      book_title = html.css('head > title').text
+      content = html.css('body > div')[1]
+      content.css('.toc').first.remove
+      content = content.inner_html
+
+      sections.each do |s|
+        content.gsub!(s['href'], s['link'])
+      end
+
+      template_dir = File.join(SCRIBE_ROOT, 'site', 'default')
+
+      # copy the template files in
+      files = Dir.glob(template_dir + '/*')
+      FileUtils.cp_r files, '.'
+
+      index_template = liquid_template('index.html')
+      page_template = liquid_template('page.html')
+
+      # write the index page
+      main_data = {
+        'book_title' => book_title,
+        'sections' => sections
+      }
+      File.open('index.html', 'w+') do |f|
+        f.puts index_template.render( main_data )
+      end
+
+      # write the title page
+      File.open('title.html', 'w+') do |f|
+        data = {
+          'title' => sections.first['title'],
+          'sub' => sections.first['sub'],
+          'prev' => {'link' => 'index.html', 'title' => "Main"},
+          'home' => {'link' => 'index.html', 'title' => "Home"},
+          'next' => sections[1],
+          'content' => content
+        }
+        data.merge!(main_data)
+        f.puts page_template.render( data )
+      end
+
+      # write the other pages
+      sections.each_with_index do |section, i|
+
+        if i > 0 # skip title page
+          source = File.read(section['href'])
+          html = Nokogiri::HTML.parse(source, nil, 'utf-8')
+
+          content = html.css('body > div')[1].to_html
+          sections.each do |s|
+            content.gsub!(s['href'], s['link'])
+          end
+
+          File.open(section['link'], 'w+') do |f|
+            next_section = nil
+            if i <= sections.size
+              next_section = sections[i+1]
+            end
+            data = {
+              'title' => section['title'],
+              'sub' => section['sub'],
+              'prev' => sections[i-1],
+              'home' => {'link' => 'index.html', 'title' => "Home"},
+              'next' => next_section,
+              'content' => content
+            }
+            data.merge!(main_data)
+            f.puts page_template.render( data )
+          end
+          #File.unlink(section['href'])
+
+          info i
+          info section['title']
+          info section['href']
+          info section['link']
+        end
+
+        #File.unlink
+      end
+      sections
+    end
+
+
+    def liquid_template(file)
+      template_dir = File.join(SCRIBE_ROOT, 'site', 'default')
+      Liquid::Template.parse(File.read(File.join(template_dir, file)))
+    end
+  end
+end