verku 0.8.0.p

data/lib/verku/parser/html.rb

@@ -0,0 +1,245 @@
+require 'kramdown'
+module Verku
+  module Parser
+    class HTML < Base 
+      def content
+        raw = []
+        entries.keys.each do |chapter|
+          text = "\n\n## Chapter\n\n"
+          sections = []
+          entries[chapter].each do |section|
+            sections << read_content(section)[0]
+            # sections << "<p>#{read_content(section)[0].split(/\n{2,}/).map do |s|
+            #   s.gsub!(/%.*/, '')
+            #   s.squish
+            # end.join("</p>\n\n<p>")}</p>"
+          end
+          text << sections.join("\n\n* * *\n\n")
+          raw << "<div class='chapter'>\n#{text.to_html}\n</div>\n"
+        end
+        raw
+      end
+      def parse
+        puts "-- Exporting HTML"
+        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)
+        f = File.open(root_dir.join("builds/#{name}.html"), 'w')
+        f.write(output)
+        f.close
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def parse_layout(chapters)
+        output = ''
+        chapters.each do |text|
+          # text.gsub!("{%", "{")
+          # text.gsub!(/%.*/,'')
+          text = text.split("\n\n").map{|s| s.gsub("\n", " ")}.join("\n\n")
+          text.gsub!(/``(.*?'?)''/) { "&ldquo;#{$1}&rdquo;"}
+          text.gsub!(/``(.*?'?)"/) { "&ldquo;#{$1}&rdquo;"}
+          text.gsub!(/``/, "&ldquo;")
+          text.gsub!(/\b'\b/) { "&rsquo;" }
+          text.gsub!(/`(.*?)'/) { "&lsquo;#{$1}&rsquo;"}
+          # \{([^\}]+?)\} Within the curly braces.
+          text.gsub!(/\\pf?break\{\}/,"<hr />")
+          text.gsub!(/\\pf?break/,"<hr />")
+          text.gsub!(/\\%/,'%')
+          text.gsub!(/\\`e/,'&eacute;')
+          text.gsub!(/\\textgreater\{?\}?/, "&gt;")
+          text.gsub!(/\\Bophendze/,'Bophendze')
+          text.gsub!(/\\ldots\{\}/,"&hellip;")
+          text.gsub!(/\\Dash\{\}/, "&mdash;")
+          text.gsub!(/\\Dash/, "&mdash;")
+          text.gsub!(/\\begin\{quote\}(.*?)\\end\{quote\}/m) { "<blockquote>#{$1.strip}</blockquote>"}
+          text.gsub!(/<\/blockquote>\s+?<blockquote>/m, "\n")
+          text.gsub!(/\\begin\{([^\}]+?)\}(.*?)\\end\{[^\}]+?\}/m) { "<div class='#{$1.strip}'>#{$2.strip}</div>"}
+          text.gsub!(/\\section\{([^\}]+?)\}/m) { "<h3>#{$1.strip}</h3>"}
+          ['Character','Equipment','Organization','Index'].each do |s|
+            text.gsub!(/\\#{s}\{[^\}]+?\}\{([^\}]+?)\}/) { "<span class='#{s.downcase}'>#{$1.strip}</span>"}
+            text.gsub!(/\\#{s}\{([^\}]+?)\}/) { ""}
+            # text.gsub!(/\\#{s}\{([^\}]+?)\}/) { "<span class='#{s.downcase}'>#{$1.strip}</span>"}
+          end
+          text.gsub!(/\\footnote\{([^\}]+?)\}/m) { ""}
+          text.gsub!(/\\emph\{([^\}]+?)\}/m) { "<em>#{$1.strip}</em>"}
+          text.gsub!(/\\thought\{([^\}]+?)\}/m) { "<em>#{$1.strip}</em>"}
+          text.gsub!(/\\(.*?)\{([^\}]+?)\}/) { "<span class='#{$1.downcase}'>#{$2.strip}</span>"}
+          text.gsub!(/\\(.*?)\{([^\}]+?)\}/) { "<span class='#{$1.downcase}'>#{$2.strip}</span>"}
+          text.gsub!(/<\/span>\{[^\}]+?}/, "</span>")
+          text.gsub!(/<p><h([1-6])>(.*?)<\/h[1-6]><\/p>/) { "<h#{$1}>#{$2.strip}</h#{$1}>"}
+          text.gsub!(/(\S+)~(\S+)/) { "#{$1}&nbsp;#{$2}"}
+          output << text
+        end
+        output.gsub!(/\n\n+/, "\n\n")
+        return 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("builds/#{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 = Verku::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/verku/parser/mobi.rb

@@ -0,0 +1,17 @@
+module Verku
+  module Parser
+    class Mobi < Base
+      def parse
+        puts "-- Exporting MOBI"
+        spawn_command ["kindlegen", epub_file.to_s,]
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def epub_file
+        root_dir.join("builds/#{name}.epub")
+      end
+    end
+  end
+end

data/lib/verku/parser/pdf.rb

@@ -0,0 +1,54 @@
+require 'kramdown'
+
+module Verku
+  module Parser
+    class PDF < Base
+      def content
+        raw = []
+        entries.keys.each do |chapter|
+          title = (chapter.empty?) ? "Untitled" : chapter.split('_')[1]
+          title = 'Untitled' if title.nil?
+          raw << "\\Chapter{#{title.gsub('-',' ')}}\n\n"
+          entries[chapter].each do |section|
+            s = read_content(section)[0].to_latex.gsub(/\$(\\index\{[^\$]*?\})\$/) {"#{$1}"}
+            raw << "#{s}\n\n* * *"
+          end
+        end
+        raw
+      end
+      
+      def parse
+        puts "-- Exporting PDF"
+        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)
+        puts "    - Pass 1"
+        spawn_command ["xelatex", tex_file.to_s,]
+        puts "    - Pass 2"
+        spawn_command ["xelatex", tex_file.to_s,]
+        if config['is_final'].to_i == 0
+          puts "    - Pass 3 - Indexing"
+          spawn_command ["makeindex #{name}.idx"]
+          # spawn_command ["makeglossaries #{name}.glo"]
+          spawn_command ["xelatex", tex_file.to_s,]
+          spawn_command ["rm *ilg *ind "]
+        end
+        
+        spawn_command ["rm *.glo *.idx *.log *.out *.toc *aux *ist"]
+        spawn_command ["mv #{name}.pdf builds/#{name}.pdf"]
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def parse_layout(text)
+        text = text.join("\n\n")
+        text.gsub!('* * *', "\n\n\\pbreak{}\n\n")
+      end
+      def tex_file
+        root_dir.join("builds/#{name}.tex")
+      end
+    end
+  end
+end

data/lib/verku/parser/txt.rb

@@ -0,0 +1 @@
+txt.rb

data/lib/verku/stats.rb

@@ -0,0 +1,114 @@
+class Fixnum
+  def day
+    self * (60 * 60 * 24) # seconds * hours * minutes
+  end
+  def ago
+    Time.now - self
+  end
+end
+require 'json'
+module Verku
+  class Stats
+    attr_reader :root_dir
+
+    def initialize(root_dir)
+      @root_dir = root_dir
+      @files = Dir["#{root_dir}/text/**/[0-9]*.tex"]
+      @words = 0
+      @progress = (File.exist?(log)) ? JSON.parse(File.open(log,'r').read).clone : {}
+    end
+
+    def log
+      "#{root_dir}/.wordcount"
+    end
+
+    def target
+      Verku.config(@root_dir)['wordcount']
+    end
+    def now
+      Date.today.to_s
+    end
+    def words
+      if @words == 0
+        most_recent = @files.max_by {|f| File.mtime(f)}
+        if !@progress[now].nil? and File.mtime(log) > File.mtime(most_recent)
+          @progress[now]
+        else
+          detex = "/usr/texbin/detex"
+
+          file = Tempfile.new('foo.tex')
+          file.write(text)
+          file.close
+          @progress[now] = `detex #{file.path}| wc -w`.to_i
+          file.unlink
+          # Do previous day's progress...if nil.
+          @progress[Date.yesterday.to_s] = @progress[now] if @progress.keys.count == 1
+        end
+      end
+      if (lasttime != Date.yesterday.to_s)
+        # Update the record.
+        n = lasttime
+        w = @progress[lasttime]
+        n.upto(Date.yesterday.to_s) do |k|
+          # puts "Upto #{k}: @progress[#{k}] = #{w}"
+          @progress[k] = w
+        end
+      end
+      File.open(log,'w').write( JSON.generate(@progress) )
+      @words = @progress[now]
+    end
+    def lasttime
+      p = nil
+      @progress.keys.sort.each do |k|
+        break if k == now
+        p = k
+      end
+      p
+    end
+    def yesterday
+      @progress[lasttime]
+    end
+    def today
+      @words - @progress[lasttime] 
+    end
+    def text
+      @text = nil
+      @text = @files.map{|f| File.open(f,'r').read}.join("\n\n\n") if @text.nil?
+    end
+    def remaining
+      target - words
+    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/verku/stream.rb

@@ -0,0 +1,27 @@
+module Verku
+  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