burr 0.0.2

data/lib/burr/exporters/pdf.rb

@@ -0,0 +1,95 @@
+module Burr
+  class PDF < Exporter
+
+    # Convert original contents into HTML
+    #
+    def parse_contents
+      parsed_items = []
+      self.book.items.each do |item|
+        self.book.current_item = item
+
+        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)
+
+        item['content'] = self.book.render(self.book.template_for(item['element']), { 'item' => item, 'toc' => toc_html })
+
+        self.run_plugins_of_type(:after_decorate)
+
+        decorated_items << self.book.current_item
+      end
+
+      self.book.items = decorated_items
+    end
+
+    def assemble_book
+      base = File.join(self.book.outputs_dir, 'pdf')
+      html_path = File.join(base, "#{self.book.slug}.html")
+      pdf_path = File.join(base, "#{self.book.slug}-#{Time.new.strftime('%Y%m%d')}.pdf")
+
+      html = self.book.render(self.book.template_for('book'), {
+               'frontmatter' => self.frontmatter,
+               'bodymatter'  => self.bodymatter,
+               'backmatter'  => self.backmatter
+              })
+      File.open(html_path, 'w') { |f| f.puts html }
+
+      system "prince #{html_path} -o #{pdf_path}"
+
+      File.unlink html_path
+    end
+
+    private
+
+    def toc_html
+      html = '<ol class="toc-list">'
+      self.book.items.each do |item|
+        # editions define the *tocable* items
+        if self.book.config['formats']['pdf']['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']
+                html << <<-LI1
+                  <li class="#{ item['matter'] } #{ item['element'] } level-#{ entry['level'] }">
+                    <a href="\##{ 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'] }">#{ item['label'] } #{ item['title'] }</a>
+            </li>
+          LI2
+        end
+      end
+      html << '</ol>'
+    end
+
+  end
+end

data/lib/burr/exporters/site.rb

@@ -0,0 +1,101 @@
+module Burr
+  class Site < Exporter
+
+    # Convert original contents into HTML
+    #
+    def parse_contents
+      parsed_items = []
+      self.book.items.each do |item|
+        self.book.current_item = item
+
+        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
+      [nil, *flatten_items(self.book.items), nil].each_cons(3) do |pre, item, nxt|
+        item['toc'] = item_toc_html(item['toc'])
+
+        unless pre.nil?
+          item['pre'] = ''
+          item['pre'] << "#{pre['label']}" unless pre['label'].blank?
+          item['pre'] << "#{pre['title']}"
+          item['pre_url'] = get_html_path_of(pre['element'], pre['file'])
+        end
+
+        unless nxt.nil?
+          item['nxt'] = ''
+          item['nxt'] << "#{nxt['label']}" unless nxt['label'].blank?
+          item['nxt'] << "#{nxt['title']}"
+          item['nxt_url'] = get_html_path_of(nxt['element'], nxt['file'])
+        end
+
+        File.open(get_html_path_of(item['element'], item['file'], false), 'w') do |f|
+          f.puts self.book.render(self.book.template_for(item['element']), { 'item' => item })
+        end
+      end
+    end
+
+    private
+
+    # Deletes item if item['element'] includes in %w(cover toc blank).
+    #
+    def flatten_items(items)
+      items.delete_if { |item| %w(cover toc blank).include?(item['element']) }
+    end
+
+    # Gets toc HTML for a single item.
+    #
+    def item_toc_html(toc)
+      # do not need the first element(level 1) in output
+      toc.shift
+
+      html = '<ol class="toc">'
+      toc.each do |entry|
+        next if entry['level'] - 1 > self.book.config['formats']['site']['toc']['deep']
+        html << <<-LI
+          <li class="level-#{ entry['level'] }">
+            <a href="\##{ entry['id'] }">#{ entry['label'] } #{ entry['title'] }</a>
+          </li>
+        LI
+      end
+      html << '</ol>'
+    end
+
+    def get_html_path_of(element, path, relative = true)
+      base = File.join(self.book.outputs_dir, 'site')
+      basename = if path.blank?
+        element
+      else
+        path.split('.')[0..-2].join('.')
+      end
+
+      return "/#{ basename }.html" if relative
+
+      File.join(base, "#{ basename }.html")
+    end
+
+  end
+end

data/lib/burr/generator.rb

@@ -0,0 +1,41 @@
+module Burr
+  class Generator < Thor::Group
+
+    include Thor::Actions
+
+    def self.source_root
+      File.dirname(__FILE__) + '/../../generators'
+    end
+
+    def copy_gemfile
+      copy_file 'Gemfile.txt', 'Gemfile'
+    end
+
+    def copy_config_file
+      copy_file 'config.yml'
+    end
+
+    def copy_contents
+      directory 'contents'
+    end
+
+    def outputs_dir
+      empty_directory 'outputs/pdf'
+      empty_directory 'outputs/site'
+      empty_directory 'outputs/epub'
+      empty_directory 'outputs/mobi'
+
+      empty_directory 'outputs/site/figures'
+    end
+
+    def copy_stylesheets
+      copy_file 'stylesheets/pdf.css', 'outputs/pdf/style.css'
+      copy_file 'stylesheets/site.css', 'outputs/site/style.css'
+    end
+
+    def caches_dir
+      empty_directory 'caches/code'
+    end
+
+  end
+end

data/lib/burr/kramdown_ext/converter.rb

@@ -0,0 +1,145 @@
+require 'burr/kramdown_ext/parser'
+require 'pygments'
+
+module Kramdown
+  module Converter
+    class Bshtml < Html
+
+      attr_accessor :book
+
+      def initialize(root, options)
+        super
+        @book = options[:register]
+      end
+
+      # Converts paragraph contents image with caption and normal paragraph.
+      #
+      def convert_p(el, indent)
+        if el.children.size == 1 && el.children.first.type == :img && !el.children.first.attr['caption'].nil?
+          convert_image_with_caption(el, indent)
+        else
+          super
+        end
+      end
+
+      # Converts the codeblock to HTML, using pygments to highlight.
+      #
+      def convert_codeblock(el, indent)
+        attr = el.attr.dup
+        lang = extract_code_language!(attr)
+        lang = 'text' if lang.blank?
+
+        pyg_opts = {
+          :encoding => 'utf-8',
+          :cssclass => "highlight type-#{lang}"
+        }
+        caption = attr['caption']
+        file    = attr['file']
+        code = ::Pygments.highlight(el.value, :lexer => lang, :options => pyg_opts).chomp << "\n"
+        output = '<div class="codeblock'
+        output << ' has-caption' if caption
+        output << '">'
+        if caption
+          caption_el = ::Kramdown::Parser::Bsmarkdown.parse(caption).first
+          caption_html = inner(caption_el.children.first, 0)
+          output << "<p class=\"caption\">#{caption_html}</p>"
+        end
+        output << "<p class=\"file\"><code>#{file}</code></p>" if file
+        output << "#{code}</div>"
+      end
+
+      # Converts headers
+      #
+      def convert_header(el, indent)
+        attr = el.attr.dup
+        item = self.book.current_item
+        if @options[:auto_ids] && !attr['id']
+          attr['id'] = generate_id(el.options[:raw_text])
+        end
+        #@toc << [el.options[:level], attr['id'], el.children] if attr['id'] && in_toc?(el)
+        unless attr['class'] == 'skip-toc'
+          item['toc'] << {
+            'level' => el.options[:level],
+            'title' => el.options[:raw_text]
+          }
+        end
+
+        level = output_header_level(el.options[:level])
+        format_as_block_html("h#{level}", attr, inner(el, indent), indent)
+      end
+
+      def convert_footnote(el, indent)
+        if self.book.format == 'pdf'
+          inline = format_as_span_html('span', { 'class'=> 'footnote', 'id' => "fn-#{ el.options[:name] }"}, inner(el.value, 0))
+          inline.sub!(/\s*<p>/, '').sub!(/<\/p>\n/, '')
+        else
+          number = @footnote_counter
+          @footnote_counter += 1
+          @footnotes << [el.options[:name], el.value]
+          "<sup class=\"footnote\" id=\"fnref-#{el.options[:name]}\"><a href=\"#fn-#{el.options[:name]}\" rel=\"footnote\">#{number}</a></sup>"
+        end
+      end
+
+      ::Kramdown::Parser::Bsmarkdown::BOXES.each do |box|
+        define_method("convert_#{box}_box") { |el, indent| <<-EOF }
+          #{' '*indent}<div class="#{box} box">\n#{inner(el, indent)}#{' '*indent}</div>\n
+        EOF
+      end
+
+      alias :orin_convert_table :convert_table
+
+      alias :convert_thead :orin_convert_table
+      alias :convert_tbody :orin_convert_table
+      alias :convert_tfoot :orin_convert_table
+      alias :convert_tr    :orin_convert_table
+
+      def convert_table(el, indent)
+        caption = el.attr.delete('caption')
+        output = '<div class="table'
+        if caption
+          caption_el = ::Kramdown::Parser::Bsmarkdown.parse(caption).first
+          caption_html = inner(caption_el.children.first, 0)
+          output << " has-caption\"><p class=\"caption\">#{caption_html}</p>"
+        else
+          output << '">'
+        end
+        output << format_as_indented_block_html(el.type, el.attr, inner(el, indent), indent)
+        output << '</div>'
+      end
+
+      # Return a HTML ordered list with the footnote content for the used footnotes.
+      def footnote_content
+        ol = Element.new(:ol)
+        ol.attr['start'] = @footnote_start if @footnote_start != 1
+        @footnotes.each do |name, data|
+          li = Element.new(:li, nil, {'id' => "fn-#{name}"})
+          li.children = Marshal.load(Marshal.dump(data.children))
+          ol.children << li
+
+          ref = Element.new(:raw, "<a href=\"#fnref-#{name}\" rel=\"reference\">&#8617;</a>")
+          if li.children.last.type == :p
+            para = li.children.last
+          else
+            li.children << (para = Element.new(:p))
+          end
+          para.children << ref
+        end
+        (ol.children.empty? ? '' : format_as_indented_block_html('div', {:class => "footnotes"}, convert(ol, 2), 0))
+      end
+
+      private
+
+      def convert_image_with_caption(el, indent)
+        img_el = el.children.first
+        caption = img_el.attr.delete('caption')
+        img_html = convert_img(img_el, indent)
+
+        caption_el = ::Kramdown::Parser::Bsmarkdown.parse(caption).first
+        caption_html = inner(caption_el.children.first, 0)
+
+        "<div class=\"figure\">#{img_html}<p class=\"caption\">#{caption_html}</p></div>"
+      end
+
+    end
+  end
+end

data/lib/burr/kramdown_ext/options.rb

@@ -0,0 +1,38 @@
+module Kramdown
+  module Options
+
+    # Parse the given value +data+ as if it was a value for the option +name+ and return the parsed
+    # value with the correct type.
+    #
+    # If +data+ already has the correct type, it is just returned. Otherwise it is converted to a
+    # String and then to the correct type.
+    def self.parse(name, data)
+      raise ArgumentError, "No option named #{name} defined" if !@options.has_key?(name)
+      if !(@options[name].type === data)
+        data = data.to_s
+        data = if @options[name].type == String
+                 data
+               elsif @options[name].type == Integer
+                 Integer(data) rescue raise Kramdown::Error, "Invalid integer value for option '#{name}': '#{data}'"
+               elsif @options[name].type == Float
+                 Float(data) rescue raise Kramdown::Error, "Invalid float value for option '#{name}': '#{data}'"
+               elsif @options[name].type == Symbol
+                 data.strip!
+                 data = data[1..-1] if data[0] == ?:
+                 (data.empty? || data == 'nil' ? nil : data.to_sym)
+               elsif @options[name].type == Boolean
+                 data.downcase.strip != 'false' && !data.empty?
+               else
+                 data
+               end
+      end
+      data = @options[name].validator[data] if @options[name].validator
+      data
+    end
+
+    define(:register, Object, nil, 'Pass in another object.') do |r|
+      r
+    end
+
+  end
+end

data/lib/burr/kramdown_ext/parser.rb

@@ -0,0 +1,65 @@
+module Kramdown
+  module Parser
+    class Bsmarkdown < Kramdown
+
+      BOXES = %w(aside discussion error information question tip warning)
+
+      def initialize(source, options)
+        super
+        @block_parsers.unshift(:gfm_codeblock_fenced, *BOXES.map{ |b| :"#{b}_box" })
+      end
+
+      GFM_FENCED_CODEBLOCK_START = /^`{3,}/
+      GFM_FENCED_CODEBLOCK_MATCH = /^(`{3,})\s*?(\w+)?\s*?\n(.*?)^\1`*\s*?\n/m
+
+      # Parser the GitHub Flavored Markdown fenced code block.
+      #
+      # Examples
+      #
+      #   ```ruby
+      #   def hello
+      #     puts 'Hello'
+      #   end
+      #   ```
+      #
+      def parse_gfm_codeblock_fenced
+        if @src.check(GFM_FENCED_CODEBLOCK_MATCH)
+          @src.pos += @src.matched_size
+          el = new_block_el(:codeblock, @src[3])
+          lang = @src[2].to_s.strip
+          el.attr['class'] = "language-#{lang}" unless lang.empty?
+          @tree.children << el
+          true
+        else
+          false
+        end
+      end
+      define_parser(:gfm_codeblock_fenced, GFM_FENCED_CODEBLOCK_START)
+
+      ASIDE_BOX_START = /^#{OPT_SPACE}A> ?/u
+      DISCUSSION_BOX_START = /^#{OPT_SPACE}D> ?/
+      ERROR_BOX_START = /^#{OPT_SPACE}E> ?/
+      INFORMATION_BOX_START = /^#{OPT_SPACE}I> ?/
+      QUESTION_BOX_START = /^#{OPT_SPACE}Q> ?/
+      TIP_BOX_START = /^#{OPT_SPACE}T> ?/
+      WARNING_BOX_START = /^#{OPT_SPACE}W> ?/
+
+      BOXES.each do |box|
+        define_method("parse_#{box}_box") do
+          result = @src.scan(PARAGRAPH_MATCH)
+          while !@src.match?(self.class::LAZY_END)
+            result << @src.scan(PARAGRAPH_MATCH)
+          end
+          result.gsub!(self.class.const_get("#{box.upcase}_BOX_START"), '')
+
+          el = new_block_el(:"#{box}_box")
+          @tree.children << el
+          parse_blocks(el, result)
+          true
+        end
+        define_parser(:"#{box}_box", self.const_get("#{box.upcase}_BOX_START"))
+      end
+
+    end
+  end
+end