kitabu 2.0.0 → 2.0.1

data/lib/kitabu/parser/html.rb

@@ -1,208 +0,0 @@
-module Kitabu
-  module Parser
-    class HTML < Base
-      # 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 erb]
-
-      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!
-        copy_images!
-        export_stylesheets!
-
-        File.open(root_dir.join("output/#{name}.html"), "w") do |file|
-          file << parse_layout(content)
-        end
-
-        true
-      rescue Exception => error
-        handle_error(error)
-        false
-      end
-
-      def reset_footnote_index!
-        self.class.footnote_index = 1
-      end
-
-      # Return all chapters wrapped in a <tt>div.chapter</tt> tag.
-      #
-      def content
-        String.new.tap do |chapters|
-          entries.each do |entry|
-            files = chapter_files(entry)
-
-            # no markup files, so skip to the next one!
-            next if files.empty?
-
-            chapters << %[<div class="chapter">#{render_chapter(files)}</div>]
-          end
-        end
-      end
-
-      # Return a list of all recognized files.
-      #
-      def entries
-        Dir.entries(source).sort.inject([]) do |buffer, entry|
-          buffer << source.join(entry) if valid_entry?(entry)
-          buffer
-        end
-      end
-
-      private
-      def chapter_files(entry)
-        # Chapters can be files outside a directory.
-        if File.file?(entry)
-          [entry]
-        else
-          Dir["#{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)
-        if format(file) == :erb
-          content = render_template(file, config)
-        else
-          content = File.read(file)
-        end
-
-        content = Kitabu::Markdown.render(content)
-        render_footnotes(content)
-      end
-
-      def render_footnotes(content)
-        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)
-        if File.extname(file) == '.erb'
-          :erb
-        else
-          :markdown
-        end
-      end
-
-      # Parse layout file, making available all configuration entries.
-      #
-      def parse_layout(html)
-        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
-        render_file(changelog) if changelog
-      end
-
-      # Render all +files+ from a given chapter.
-      #
-      def render_chapter(files)
-        String.new.tap do |chapter|
-          files.each do |file|
-            chapter << render_file(file) << "\n\n"
-          end
-        end
-      end
-
-      # Copy images
-      #
-      def copy_images!
-        copy_directory("images", "output/images")
-      end
-
-      # Export all root stylesheets.
-      #
-      def export_stylesheets!
-        files = Dir[root_dir.join("templates/styles/*.{scss,sass}").to_s]
-        options = {
-          style: :expanded,
-          line_numbers: true,
-          load_paths: [root_dir.join("templates/styles")]
-        }
-
-        files.each do |file|
-          _, file_name, syntax = *File.basename(file).match(/(.*?)\.(.*?)$/)
-          engine = Sass::Engine.new(File.read(file), options.merge(syntax: syntax.to_sym))
-          target = root_dir.join("output/styles", "#{file_name}.css")
-          FileUtils.mkdir_p(File.dirname(target))
-          File.open(target, "w") {|io| io << engine.render }
-        end
-      end
-    end
-  end
-end

data/lib/kitabu/parser/pdf.rb

@@ -1,88 +0,0 @@
-module Kitabu
-  module Parser
-    class PDF < Base
-      def parse
-        apply_footnotes!
-        spawn_command ["prince", html_for_pdf.to_s, "-o", pdf_file.to_s]
-        spawn_command ["prince", html_for_print.to_s, "-o", print_file.to_s]
-      end
-
-      def apply_footnotes!
-        html = Nokogiri::HTML(html_file.read)
-        footnote_count = 1
-
-        # https://github.com/sparklemotion/nokogiri/issues/339
-        html.css("html").first.tap do |element|
-          next unless element
-          element.delete("xmlns")
-          element.delete("xml:lang")
-        end
-
-        chapters = html.css(".chapter")
-
-        chapters.each do |chapter|
-          footnotes = chapter.css(".footnotes li")
-
-          footnotes.each do |fn|
-            # Get current footnote number
-            footnote_number = footnote_count
-            footnote_count += 1
-
-            # Remove rev links
-            fn.css('[rev=footnote]').map(&:remove)
-
-            # Create an element for storing the footnote description
-            fn_desc = Nokogiri::XML::Node.new('span', Nokogiri::HTML::DocumentFragment.parse(''))
-            fn_desc.set_attribute 'class', 'fn-desc'
-            fn_desc.inner_html = fn.css('p').map(&:inner_html).join("\n")
-
-            # Find ref based on footnote's id
-            fn_id = fn.get_attribute('id')
-            ref = chapter.css("a[href='##{fn_id}']").first
-
-            # Go up to parent and reformat it.
-            sup = ref.parent
-            sup.delete("id")
-            sup.set_attribute 'class', 'fn-ref'
-            sup.inner_html = ''
-
-            # Finally, add the description after the <sup> tag.
-            sup.after(fn_desc)
-          end
-
-          # Remove the footnotes element
-          chapter.css('.footnotes').map(&:remove)
-        end
-
-        create_html_file(html_for_print, html, 'print')
-        create_html_file(html_for_pdf, html, 'pdf')
-      end
-
-      def create_html_file(target, html, class_name)
-        html.css("html").first.set_attribute "class", class_name
-        html.css("link[name=stylesheet]").first.set_attribute "href", "styles/#{class_name}.css"
-        File.open(target, "w") {|f| f << html.to_html }
-      end
-
-      def html_for_pdf
-        root_dir.join("output/#{name}.pdf.html")
-      end
-
-      def html_for_print
-        root_dir.join("output/#{name}.print.html")
-      end
-
-      def html_file
-        root_dir.join("output/#{name}.html")
-      end
-
-      def pdf_file
-        root_dir.join("output/#{name}.pdf")
-      end
-
-      def print_file
-        root_dir.join("output/#{name}.print.pdf")
-      end
-    end
-  end
-end