RubyGems - bookmaker - Versions diffs - 0.1.0 - Mend

bookmaker 0.1.0

Files changed (36) hide show

data/.gitignore +4 -0
data/Gemfile +4 -0
data/Rakefile +1 -0
data/Readme.md +0 -0
data/bin/bookmaker +5 -0
data/bookmaker.gemspec +37 -0
data/features/basic.feature +8 -0
data/features/export.feature +8 -0
data/features/support/setup.rb +1 -0
data/lib/bookmaker.rb +54 -0
data/lib/bookmaker/adapters/markdown.rb +35 -0
data/lib/bookmaker/cli.rb +74 -0
data/lib/bookmaker/dependency.rb +19 -0
data/lib/bookmaker/exporter.rb +68 -0
data/lib/bookmaker/extensions/string.rb +11 -0
data/lib/bookmaker/generator.rb +40 -0
data/lib/bookmaker/parser.rb +81 -0
data/lib/bookmaker/parser/epub.rb +137 -0
data/lib/bookmaker/parser/html.rb +199 -0
data/lib/bookmaker/parser/mobi.rb +14 -0
data/lib/bookmaker/parser/pdf.rb +40 -0
data/lib/bookmaker/stats.rb +45 -0
data/lib/bookmaker/stream.rb +27 -0
data/lib/bookmaker/toc.rb +6 -0
data/lib/bookmaker/toc/epub.rb +41 -0
data/lib/bookmaker/toc/html.rb +78 -0
data/lib/bookmaker/version.rb +3 -0
data/templates/config.erb +51 -0
data/templates/epub.css +500 -0
data/templates/epub.erb +15 -0
data/templates/html.erb +42 -0
data/templates/latex.erb +201 -0
data/templates/sample.md +24 -0
data/templates/syntax.css +58 -0
data/templates/user.css +1 -0
metadata +172 -0

@@ -0,0 +1,137 @@
+module Bookmaker
+  module Parser
+    class Epub < Base
+      def sections
+        @sections ||= html.css("div.section").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
+      end
+      def epub; @epub ||= EeePub.make ;end
+      def html; @html ||= Nokogiri::HTML(html_path.read); 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.save(epub_path)
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def write_toc!
+        toc = TOC::Epub.new(navigation)
+        File.open(toc_path, "w") do |file|
+          file << toc.to_html
+        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
+        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"
+          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
+        end
+      end
+      def render_chapter(content)
+        locals = config.merge(:content => content)
+        render_template(template_path, locals)
+      end
+      def assets
+        @assets ||= begin
+          assets = Dir[root_dir.join("templates/epub/*.css")]
+          assets += Dir[root_dir.join("images/**/*.{jpg,png,gif}")]
+          assets
+        end
+      end
+      def cover_image
+        path = Dir[root_dir.join("templates/epub/cover.{jpg,png,gif}").to_s].first
+        return path if path && File.exist?(path)
+      end
+      def navigation
+        sections.map do |section|
+          {
+            :label => section.html.css("h2:first-of-type").text,
+            :content => section.filename
+          }
+        end
+      end
+      def template_path
+        root_dir.join("templates/epub/page.erb")
+      end
+      def html_path
+        root_dir.join("output/#{name}.html")
+      end
+      def epub_path
+        root_dir.join("output/#{name}.epub")
+      end
+      def tmp_dir
+        root_dir.join("output/tmp")
+      end
+      def toc_path
+        tmp_dir.join("toc.html")
+      end
+    end
+  end
+end

data/lib/bookmaker/parser/html.rb ADDED

@@ -0,0 +1,199 @@
+require 'kramdown'
+module Bookmaker
+  module Parser
+    class HTML < Base
+      def content
+        raw = []
+        entries.keys.each do |chapter|
+          raw << "{::nomarkdown}<h2>#{chapter.split(/_/)[1].gsub('-',' ')}</h2>{:/}"
+          entries[chapter].each do |section|
+            raw << read_content(section)[0] + "\n\n* * *"
+          end
+        end
+        raw
+      end
+      def parse
+        html = parse_layout(content)
+        toc = TOC::HTML.generate(html)
+        locals = config.merge({
+                  :contents  => toc.content,
+                  :toc       => toc.to_html,
+                 })
+        output = render_template(root_dir.join("templates/html/layout.erb"), locals)
+        File.open(root_dir.join("output/#{name}.html"), 'w').write(output)
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def parse_layout(text)
+        output = ""
+        text.each do |s|
+         output << "<div class='section'>\n#{Kramdown::Document.new(s).to_html}\n</div>\n"
+        end
+        output
+      end
+    end
+     #  # List of directories that should be skipped.
+     #   #
+     #   IGNORE_DIR = %w[. .. .svn]
+     #
+     #   # Files that should be skipped.
+     #   #
+     #   IGNORE_FILES = /^(CHANGELOG|TOC)\..*?$/
+     #
+     #   # List of recognized extensions.
+     #   #
+     #   EXTENSIONS = %w[md mkdn markdown]
+     #
+     #   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
+     #
+     #   # Parse all files and save the parsed content
+     #   # to <tt>output/book_name.html</tt>.
+     #   #
+     #   def parse
+     #     reset_footnote_index!
+     #
+     #     # File.open(root_dir.join("output/#{name}.html"), "w") do |file|
+     #     #   file << parse_layout(content)
+     #     # end
+     #     true
+     #   rescue Exception
+     #     false
+     #   end
+     #
+     #   def reset_footnote_index!
+     #     self.class.footnote_index = 1
+     #   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.
+     #   #
+     #   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?(source.join(entry)) && !IGNORE_DIR.include?(File.basename(entry))
+     #   end
+     #
+     #   # Check if path is a valid file.
+     #   #
+     #   def valid_file?(entry)
+     #     ext = File.extname(entry).gsub(/\./, "").downcase
+     #     File.file?(source.join(entry)) && EXTENSIONS.include?(ext) && entry !~ IGNORE_FILES
+     #   end
+     #
+     #   # Render +file+ considering its extension.
+     #   #
+     #   def render_file(file, plain_syntax = false)
+     #     file_format = format(file)
+     #
+     #     content = Bookmaker::Syntax.render(root_dir, file_format, File.read(file), plain_syntax)
+     #
+     #     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)
+     #     puts "parse layout."
+     #     toc = TOC::HTML.generate(html)
+     #     locals = config.merge({
+     #       :content   => toc.content,
+     #       :toc       => toc.to_html,
+     #       :changelog => render_changelog
+     #     })
+     #     render_template(root_dir.join("templates/html/layout.erb"), locals)
+     #   end
+     #
+     #   # Render changelog file.
+     #   # This file can be used to inform any book change.
+     #   #
+     #   def render_changelog
+     #     changelog = Dir[root_dir.join("text/CHANGELOG.*")].first
+     #     return render_file(changelog) if changelog
+     #     nil
+     #   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

data/lib/bookmaker/parser/mobi.rb ADDED

@@ -0,0 +1,14 @@
+module Bookmaker
+  module Parser
+    class Mobi < Base
+      def parse
+        spawn_command ["kindlegen", epub_file.to_s,]
+        true
+      end
+      def epub_file
+        root_dir.join("output/#{name}.epub")
+      end
+    end
+  end
+end

data/lib/bookmaker/parser/pdf.rb ADDED

@@ -0,0 +1,40 @@
+require 'kramdown'
+module Bookmaker
+  module Parser
+    class PDF < Base
+      def content
+        raw = []
+        entries.keys.each do |chapter|
+          raw << "{::nomarkdown}\\Chapter{#{chapter.split(/_/)[1].gsub('-',' ')}}{:/}"
+          entries[chapter].each do |section|
+            raw << read_content(section)[0] + "\n\n* * *"
+          end
+        end
+        raw
+      end
+      def parse
+        locals = config.merge({ :contents => parse_layout(content) })
+        locals['copyright'].gsub!("(C)", "\\copyright{}")
+        output = render_template(root_dir.join("templates/pdf/layout.erb"), locals)
+        File.open(root_dir.join(tex_file), 'w').write(output)
+        spawn_command ["xelatex", tex_file.to_s,]
+        spawn_command ["xelatex", tex_file.to_s,]
+        spawn_command ["rm *.glo *.idx *.log *.out *.toc *aux"]
+        spawn_command ["mv #{name}.pdf output/#{name}.pdf"]
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def parse_layout(text)
+        text = text.join("\n\n")
+        text.gsub!('* * *', "\n\n{::nomarkdown}\\pbreak{:/}\n\n")
+        Kramdown::Document.new(text).to_latex
+      end
+      def tex_file
+        root_dir.join("output/#{name}.tex")
+      end
+    end
+  end
+end

data/lib/bookmaker/stats.rb ADDED

@@ -0,0 +1,45 @@
+module Bookmaker
+  class Stats
+    attr_reader :root_dir
+    def initialize(root_dir)
+      @root_dir = root_dir
+    end
+    def text
+      @text ||= html.text
+    end
+    def html
+      @html ||= Nokogiri::HTML(content)
+    end
+    def words
+      @words ||= text.split(" ").size
+    end
+    def chapters
+      @chapters ||= html.css(".chapter").size
+    end
+    def images
+      @images ||= html.css("img").size
+    end
+    def footnotes
+      @footnotes ||= html.css("p.footnote").size
+    end
+    def links
+      @links ||= html.css("[href^='http']").size
+    end
+    def code_blocks
+      @code_blocks ||= html.css("pre").size
+    end
+    def content
+      @content ||= Parser::HTML.new(root_dir).content
+    end
+  end
+end

data/lib/bookmaker/stream.rb ADDED

@@ -0,0 +1,27 @@
+module Bookmaker
+  class Stream
+    attr_accessor :listener, :content
+    attr_reader :html
+    def initialize(content, listener)
+      @content  = content
+      @listener = listener
+      @html = Nokogiri::HTML.parse(content)
+    end
+    def parse
+      traverse(html)
+    end
+    def traverse(node)
+      node.children.each do |child|
+        emit(child)
+        traverse(child)
+      end
+    end
+    def emit(node)
+      listener.send(:tag, node) if node.name =~ /h[1-6]/
+    end
+  end
+end