burr 0.0.2

data/lib/burr/dependency.rb

@@ -0,0 +1,28 @@
+module Burr
+  module Dependency
+
+    # Checks if PrinceXML installed.
+    #
+    # Returns true if installed, otherwise false.
+    def self.prince_installed?
+      installed? 'prince'
+    end
+
+    def self.kindlegen_installed?
+      installed? 'kindlegen'
+    end
+
+    # Checks if Dependent libx installed.
+    #
+    # Returns true if installed, otherwise false.
+    def self.installed?(cmd)
+      return true if which(cmd)
+      false
+    end
+
+    # Finds the executable.
+    def self.which(cmd)
+      system "which #{cmd} > /dev/null 2>&1"
+    end
+  end
+end

data/lib/burr/eeepub_ext/maker.rb

@@ -0,0 +1,131 @@
+# Custom the eeepub maker.
+
+require 'tmpdir'
+require 'fileutils'
+
+module Burr
+  class EpubMaker
+    [
+      :title,
+      :creator,
+      :publisher,
+      :date,
+      :language,
+      :subject,
+      :description,
+      :rights,
+      :relation
+    ].each do |name|
+      class_eval <<-DELIM
+        def #{name}(value)
+          @#{name}s ||= []
+          @#{name}s << value
+        end
+      DELIM
+    end
+
+    [
+      :uid,
+      :files,
+      :nav,
+      :cover,
+      :ncx_file,
+      :opf_file,
+      :guide
+    ].each do |name|
+      define_method(name) do |arg|
+        instance_variable_set("@#{name}", arg)
+      end
+    end
+
+    def identifier(id, options)
+      @identifiers ||= []
+      @identifiers << {:value => id, :scheme => options[:scheme], :id => options[:id]}
+    end
+
+    # @param [Proc] block the block for initialize
+    def initialize(&block)
+      @files ||= []
+      @nav ||= []
+      @ncx_file ||= 'toc.ncx'
+      @opf_file ||= 'content.opf'
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Save as ePub file
+    #
+    # @param [String] filename the ePub file name to save
+    def save(filename)
+      create_epub.save(filename)
+    end
+
+    # instead of saving to file, output the file contents.
+    # important for serving on-the-fly doc creation from
+    # web interface where we don't want to allow file system
+    # writes (Heroku, et al.)
+    def render
+      create_epub.render
+    end
+
+    private
+
+    def create_epub
+      @uid ||= 'BookId'
+      unique_identifier = @identifiers.select{ |i| i[:id] == @uid }.first
+      unless unique_identifier
+        unique_identifier = @identifiers.first
+        unique_identifier[:id] = @uid
+      end
+      dir = Dir.mktmpdir
+      @files.each do |file|
+        case file
+        when String
+          FileUtils.cp(file, dir)
+        when Hash
+          file_path, dir_path = *file.first
+          dest_dir = File.join(dir, dir_path)
+          FileUtils.mkdir_p(dest_dir)
+          FileUtils.cp(file_path, dest_dir)
+        end
+      end
+
+      ::EeePub::NCX.new(
+        :uid => @identifiers.select{ |i| i[:id] == @uid }.first,
+        :title => @titles[0],
+        :nav => @nav
+      ).save(File.join(dir, @ncx_file))
+
+      ::EeePub::OPF.new(
+        :title => @titles,
+        :unique_identifier => @uid,
+        :identifier => @identifiers,
+        :creator => @creators,
+        :publisher => @publishers,
+        :date => @dates,
+        :language => @languages,
+        :subject => @subjects,
+        :description => @descriptions,
+        :rights => @rightss,
+        :cover => @cover,
+        :relation => @relations,
+        :manifest => @files.map{|file|
+          case file
+          when String
+            File.basename(file)
+          when Hash
+            file_path, dir_path = *file.first
+            File.join(dir_path, File.basename(file_path))
+          end
+        },
+        :ncx => @ncx_file,
+        :guide => @guide
+      ).save(File.join(dir, @opf_file))
+
+      ::EeePub::OCF.new(
+        :dir => dir,
+        :container => @opf_file
+      )
+    end
+  end
+end

data/lib/burr/exporter.rb

@@ -0,0 +1,137 @@
+module Burr
+  class Exporter
+
+    FRONTMATTER = %w(acknowledgement author cover dedication edition foreword
+                     introduction license preface prologue title toc)
+    BODYMATTER  = %w(appendix blank chapter conclusion part)
+    BACKMATTER  = %w(afterword epilogue glossary lof lot)
+
+    attr_accessor :book, :config
+    attr_accessor :frontmatter, :bodymatter, :backmatter
+
+    def initialize(book)
+      @book = book
+      @config = book.config
+
+      @frontmatter = []
+      @bodymatter  = []
+      @backmatter  = []
+
+      prepare_output_dir
+    end
+
+    # Run all hooks of a type.
+    #
+    # type - The plugin name in Symbol, valid options are: :before_parse, :after_parse
+    #        :before_decorate, :after_decorate.
+    #
+    # Returns nothing.
+    def run_plugins_of_type(type)
+      type = type.to_sym
+
+      Burr::Plugin.subclasses.each do |k|
+        k_obj = k.new(self.book)
+        Burr::Plugin::VALIDS.each do |h|
+          k_obj.send(type) if k_obj.respond_to?(h) && h == type
+        end
+      end
+
+      nil
+    end
+
+    # Run exporter.
+    #
+    # The details should implement in subclass.
+    def run
+      self.load_contents
+      self.parse_contents
+      self.decorate_contents
+      self.assemble_book
+    end
+
+    # Load book contents
+    def load_contents
+      special_elements = %w(cover toc blank)
+
+      self.config['contents'].each do |content_config|
+        item = initialize_item(content_config)
+
+        # if the element defines its own content file (usually: `chapter`, `appendix`)
+        if !item['file'].blank?
+          content_file = File.join(self.book.contents_dir, item['file'])
+
+          # check that content file exists and is readable
+          if !File.readable? content_file
+            raise <<-MESSAGE % content_config['file'], item['element'], "outputs/#{content_config['file']}"
+            The '%s' content associated with '%s' element doesn't exist\n
+            or is not readable.\n\n
+            Check that '%s'\n
+            file exists and check its permissions.
+            MESSAGE
+          end
+
+          item['original'] = File.read(content_file)
+        elsif item['file'].blank? && special_elements.include?(item['element'])
+          item['skip'] = true
+        else
+          # look for a default content defined by burr for this element
+          # e.g. `cover.md`, `license.md`, `title.md`
+          default_content_file = File.join(self.book.contents_dir, "#{item['element']}.md")
+          if File.exist?(default_content_file)
+            item['original'] = File.read(default_content_file)
+          else
+            self.book.ui.error("Missing file for #{item['element']}")
+            exit 1
+          end
+        end
+
+        self.frontmatter << item if item['matter'] == 'frontmatter'
+        self.bodymatter  << item if item['matter'] == 'bodymatter'
+        self.backmatter  << item if item['matter'] == 'backmatter'
+        self.book.items  << item
+      end
+    end
+
+    private
+
+    def initialize_item(configs)
+      item = {
+        'element'  => '', # the type of this content (`chapter', `appendix', `toc', `license', ...)
+        'number'   => '', # the number/letter of the content (useful for `chapter', `part' and `appendix')
+        'c_title'  => '', # the title of the content defined in `config.yml' (usually only `part' defines it)
+        'title'    => '', # the `title' of this file, the first h1 in `content'
+        'original' => '', # original content as written by book author
+        'content'  => '', # transformed content of the element (HTML usually)
+        'file'     => '', # the name of this item contents file (it's a relative path from book's `contents/')
+        'toc'      => [], # the table of contents of this element
+        'skip'     => false, # some elements, like `toc', do not need to covert, so just skip
+      }
+
+      item.merge!(configs)
+
+      # set the matter
+      if FRONTMATTER.include?(item['element'])
+        item['matter'] = 'frontmatter'
+      elsif BODYMATTER.include?(item['element'])
+        item['matter'] = 'bodymatter'
+      elsif BACKMATTER.include?(item['element'])
+        item['matter'] = 'backmatter'
+      else
+        self.book.ui.error("Element #{ item['element'] } not defined!")
+        exit 1
+      end
+
+      item
+    end
+
+    # If the outpus directory for current format not exists, create it!
+    #
+    def prepare_output_dir
+      dir = File.join(self.book.outputs_dir, self.book.format)
+      if !File.exist?(dir)
+        FileUtils.mkdir_p dir
+      end
+    end
+
+  end
+end

data/lib/burr/exporters/epub.rb

@@ -0,0 +1,163 @@
+module Burr
+  class Epub < Exporter
+
+    # Convert original contents into HTML
+    #
+    def parse_contents
+      parsed_items = []
+      self.book.items.each do |item|
+        self.book.current_item = item
+
+        # 'blank' element not include in epub
+        next if item['element'] == 'blank'
+
+        self.run_plugins_of_type(:before_parse)
+
+        unless item['skip']
+          item['content'] = Burr::Converter.new(self.book).convert(item['original'])
+        end
+
+        self.run_plugins_of_type(:after_parse)
+
+        parsed_items << self.book.current_item
+      end
+      self.book.items = parsed_items
+    end
+
+    # Decorate the contents with template
+    #
+    def decorate_contents
+      decorated_items = []
+      self.book.items.each do |item|
+        self.book.current_item = item
+        self.run_plugins_of_type(:before_decorate)
+        self.run_plugins_of_type(:after_decorate)
+        decorated_items << self.book.current_item
+      end
+      self.book.items = decorated_items
+    end
+
+    def assemble_book
+      # 1. create html files
+      special_elements = %w(blank)
+      base = File.join(self.book.outputs_dir, 'epub')
+      included_files = []
+      tmp_files = []
+
+      self.book.items.each do |item|
+        next if special_elements.include?(item['element'])
+
+        basename = if item['file'].blank?
+          item['element']
+        else
+          item['file'].split('.')[0..-2].join('.')
+        end
+        html_path = File.join(base, "#{ basename }.html")
+        included_files << html_path
+        tmp_files << html_path
+
+        File.open(html_path, 'w') do |f|
+          f.puts self.book.render(self.book.template_for(item['element']), { 'item' => item, 'toc' => html_toc })
+        end
+      end
+
+      # 2. add other files
+      included_files << File.join(base, 'style.css')
+      Dir.glob(File.join(self.book.outputs_dir, 'site', 'figures', '*.*')) do |figure|
+        included_files << { figure => 'figures' }
+      end
+      included_files << File.join(base, 'cover.jpg')
+
+      # 3. build epub file
+      config = self.book.config
+      nav = ncx_toc
+      guide = build_guide
+
+      epub = Burr::EpubMaker.new do
+        title      config['title']
+        creator    config['translator'].blank? ? config['author'] : config['translator']
+        publisher  config['publisher']
+        date       config['pubdate']
+        identifier config['identifier'], :scheme => config['id_scheme'], :id => config['slug']
+        uid        config['slug']
+        language   config['language']
+        cover      'cover.jpg'
+
+        files included_files
+        nav nav
+        guide guide
+      end
+
+      epub.save(File.join(base, "#{self.book.config['slug']}-#{Time.new.strftime('%Y%m%d')}.epub"))
+
+      # 4. remove useless files
+      tmp_files.each do |file|
+        FileUtils.remove_entry(file)
+      end
+    end
+
+    private
+
+    def ncx_toc
+      nav = []
+      self.book.items.each do |item|
+        special_elements = %w(cover toc blank)
+        next if special_elements.include?(item['element'])
+        level_1 = item['toc'].first
+        next unless level_1['level'] == 1
+        basename = if item['file'].blank?
+          item['element']
+        else
+          item['file'].split('.')[0..-2].join('.')
+        end
+        html_path = "#{ basename }.html"
+        nav_label = if level_1['label'].blank?
+          "#{level_1['title']}"
+        else
+          "#{level_1['label']} #{level_1['title']}"
+        end
+        nav << { :label => nav_label, :content => html_path }
+      end
+
+      nav
+    end
+
+    def html_toc
+      html = '<ol class="toc-list">'
+      self.book.items.each do |item|
+        # editions define the *tocable* items
+        if self.book.config['formats']['epub']['toc']['elements'].include?(item['element'])
+          # item has several elements in its toc
+          if item['toc'].size > 0
+            item['toc'].each do |entry|
+              if entry['level'] <= self.book.config['formats'][self.book.format]['toc']['deep']
+                anchor = "#{item['element']}#{entry['id'].split('-')[1]}.html"
+                html << <<-LI1
+                  <li class="#{ item['matter'] } #{ item['element'] } level-#{ entry['level'] }">
+                    <a href="#{ anchor }##{ entry['id']}">#{ entry['label'] } #{ entry['title'] }</a>
+                  </li>
+                LI1
+              end
+            end
+          end
+
+        # empty or special item (anything different from 'chapter' and 'appendix')
+        elsif !%w(cover blank toc).include?(item['element'])
+          html << <<-LI2
+            <li class="#{ item['matter'] } #{ item['element'] } level-1">
+              <a href="#{ item['id'] }.html">#{ item['title'] }</a>
+            </li>
+          LI2
+        end
+      end
+      html << '</ol>'
+    end
+
+    def build_guide
+      o = []
+      o << { :type => 'toc', :href => "toc.html", :title => 'Table of Contents' }
+      o << { :type => 'cover', :href => "cover.html", :title => 'Cover' }
+    end
+
+  end
+end