gollum 2.0.0 → 2.1.0

data/lib/gollum/tex.rb

@@ -2,6 +2,7 @@ require 'fileutils'
 require 'shellwords'
 require 'tmpdir'
 require 'posix/spawn'
+require 'base64'
 
 module Gollum
   module Tex
@@ -10,80 +11,356 @@ module Gollum
     extend POSIX::Spawn
 
     Template = <<-EOS
-\\documentclass[12pt]{article}
-\\usepackage{color}
-\\usepackage[dvips]{graphicx}
+\\documentclass[11pt]{article}
 \\pagestyle{empty}
-\\pagecolor{white}
-\\begin{document}
-{\\color{black}
-\\begin{eqnarray*}
-%s
-\\end{eqnarray*}}
+\\setlength{\\topskip}{0pt}
+\\setlength{\\parindent}{0pt}
+\\setlength{\\abovedisplayskip}{0pt}
+\\setlength{\\belowdisplayskip}{0pt}
+
+\\usepackage{geometry}
+
+\\usepackage{amsfonts}
+\\usepackage{amsmath}
+
+\\newsavebox{\\snippetbox}
+\\newlength{\\snippetwidth}
+\\newlength{\\snippetheight}
+\\newlength{\\snippetdepth}
+\\newlength{\\pagewidth}
+\\newlength{\\pageheight}
+\\newlength{\\pagemargin}
+
+\\begin{lrbox}{\\snippetbox}%
+\$%s\$
+\\end{lrbox}
+
+\\settowidth{\\snippetwidth}{\\usebox{\\snippetbox}}
+\\settoheight{\\snippetheight}{\\usebox{\\snippetbox}}
+\\settodepth{\\snippetdepth}{\\usebox{\\snippetbox}}
+
+\\setlength\\pagemargin{4pt}
+
+\\setlength\\pagewidth\\snippetwidth
+\\addtolength\\pagewidth\\pagemargin
+\\addtolength\\pagewidth\\pagemargin
+
+\\setlength\\pageheight\\snippetheight
+\\addtolength{\\pageheight}{\\snippetdepth}
+\\addtolength\\pageheight\\pagemargin
+\\addtolength\\pageheight\\pagemargin
+
+\\newwrite\\foo
+\\immediate\\openout\\foo=\\jobname.dimensions
+  \\immediate\\write\\foo{snippetdepth = \\the\\snippetdepth}
+  \\immediate\\write\\foo{snippetheight = \\the\\snippetheight}
+  \\immediate\\write\\foo{snippetwidth = \\the\\snippetwidth}
+  \\immediate\\write\\foo{pagewidth = \\the\\pagewidth}
+  \\immediate\\write\\foo{pageheight = \\the\\pageheight}
+  \\immediate\\write\\foo{pagemargin = \\the\\pagemargin}
+\\closeout\\foo
+
+\\geometry{paperwidth=\\pagewidth,paperheight=\\pageheight,margin=\\pagemargin}
+
+\\begin{document}%
+\\usebox{\\snippetbox}%
 \\end{document}
     EOS
 
     class << self
-      attr_accessor :latex_path, :dvips_path, :convert_path
+      attr_accessor :latex_path
     end
 
-    self.latex_path   = 'latex'
-    self.dvips_path   = 'dvips'
-    self.convert_path = 'convert'
+    self.latex_path   = 'pdflatex'
 
     def self.check_dependencies!
       return if @dependencies_available
 
-      if `which latex` == ""
-        raise Error, "`latex` command not found"
+      if `which pdflatex` == ""
+        raise Error, "`pdflatex` command not found"
       end
 
-      if `which dvips` == ""
-        raise Error, "`dvips` command not found"
+      if `which gs` == ""
+        raise Error, "`gs` command not found"
+      end
+      
+      if `which pnmcrop` == ""
+        raise Error, "`pnmcrop` command not found"
       end
 
-      if `which convert` == ""
-        raise Error, "`convert` command not found"
+      if `which pnmpad` == ""
+        raise Error, "`pnmpad` command not found"
       end
 
-      if `which gs` == ""
-        raise Error, "`gs` command not found"
+      if `which pnmscale` == ""
+        raise Error, "`pnmscale` command not found"
+      end
+      
+      if `which ppmtopgm` == ""
+        raise Error, "`ppmtopgm` command not found"
+      end
+      
+      if `which pnmgamma` == ""
+        raise Error, "`pnmgamma` command not found"
+      end
+      
+      if `which pnmtopng` == ""
+        raise Error, "`pnmtopng` command not found"
       end
 
       @dependencies_available = true
     end
 
-    def self.render_formula(formula)
+    # Render the formula and calculate the correct alignment
+    # for the image in the html. 
+    #
+    # This is a ruby implementation of the Perl version described 
+    # at http://tex.stackexchange.com/questions/44486/pixel-perfect-vertical-alignment-of-image-rendered-tex-snippets
+    #
+    # The main caveat is that rendering takes quite a bit of processing power,
+    # which can make the page load slowly if it has to render each time. 
+    # For this reason, the method caches the rendered formula in `/tmp` for reduced
+    # loading time in subsequent loads.
+    #   
+    # @param formula the tex formula to render
+    # @param with_properties, if true it returns an array with a base64
+    #   string with the image, and the alignment values for the image. 
+    #   Otherwise it returns the binary image.
+    def self.render_formula(formula, with_properties=false)
       check_dependencies!
 
-      Dir.mktmpdir('tex') do |path|
-        tex_path = ::File.join(path, 'formula.tex')
-        dvi_path = ::File.join(path, 'formula.dvi')
-        eps_path = ::File.join(path, 'formula.eps')
-        png_path = ::File.join(path, 'formula.png')
+      render_antialias_bits = 4
+        render_oversample = 4
+        display_oversample = 4
+        gamma = 0.3
+        if !with_properties
+            display_oversample = 1
+            gamma = 0.5
+        end
 
-        ::File.open(tex_path, 'w') { |f| f.write(Template % formula) }
+        oversample = render_oversample * display_oversample
+        render_dpi = 96*1.2 * 72.27/72 * oversample # This is 1850.112 dpi.
 
-        result = sh latex_path, '-interaction=batchmode', 'formula.tex', :chdir => path
-        raise Error, "`latex` command failed: #{result}" unless ::File.exist?(dvi_path)
 
-        result = sh dvips_path, '-o', eps_path, '-E', dvi_path
-        raise Error, "`dvips` command failed: #{result}" unless ::File.exist?(eps_path)
-        result = sh convert_path, '+adjoin',
-          '-antialias',
-          '-transparent', 'white',
-          '-density', '150x150',
-          eps_path, png_path
-        raise Error, "`convert` command failed: #{result}" unless ::File.exist?(png_path)
+        # Cache rendered formula and returned cached version if it exists
 
-        ::File.read(png_path)
-      end
+        # First look for the .cache directory in the home folder
+        cache_dir = ::File.expand_path("~/.cache") 
+        if not ::File.exists?(cache_dir) or not ::File.directory?(cache_dir)
+            ::Dir.mkdir(cache_dir)
+        end
+
+        # Check that the gollum directory exists inside the cache dir
+        cache_dir = ::File.join(cache_dir, "gollum")
+        if not ::File.exists?(cache_dir) or not ::File.directory?(cache_dir)
+            ::Dir.mkdir(cache_dir)
+        end
+
+        # Check for the formula in the cache dir
+        hash = Digest::SHA1.hexdigest(formula)
+        cache_file = ::File.join(cache_dir, "tex-#{hash}")
+
+        if ::File.exists?(cache_file)
+            width, height, align, base64 = ::File.open(cache_file, 'rb') { |io| io.read }.split(",")
+
+            if with_properties
+                return width, height, align, base64
+            else
+                return Base64.decode64(base64)
+            end
+        end
+        
+        Dir.mktmpdir('tex') do |path|
+            file = ::File.join(path, "formula")
+
+            # --- Write TeX source and compile to PDF.Write snippet into template
+            ::File.open(file + ".tex", 'w') { |f| f.write(Template % formula) }
+
+            result = sh_chdir path, "pdflatex",
+                "-halt-on-error",
+                "-output-directory=#{path}",
+                "-output-format=pdf",
+                "#{file}.tex",
+                ">#{file}.err 2>&1"
+
+
+
+            # --- Convert PDF to PNM using Ghostscript.
+            sh "gs",
+                "-q -dNOPAUSE -dBATCH",
+                "-dTextAlphaBits=#{render_antialias_bits}",
+                "-dGraphicsAlphaBits=#{render_antialias_bits}",
+                "-r#{render_dpi}",
+                "-sDEVICE=pnmraw",
+                "-sOutputFile=#{file}.pnm",
+                "#{file}.pdf"
+
+
+            img_width, img_height = pnm_width_height(file + ".pnm")
+
+
+            # --- Read dimensions file written by TeX during processing.
+            #
+            #     Example of file contents:
+            #       snippetdepth = 6.50009pt
+            #       snippetheight = 13.53899pt
+            #       snippetwidth = 145.4777pt
+            #       pagewidth = 153.4777pt
+            #       pageheight = 28.03908pt
+            #       pagemargin = 4.0pt
+            dimensions = {}
+            ::File.open(file + ".dimensions").readlines.each_with_index do |line, i|
+                if line =~ /^(\S+)\s+=\s+(-?[0-9\.]+)pt$/
+                    dimensions[$1] = Float($2) / 72.27 * render_dpi
+                else 
+                    raise Error, "#{file}.dimensions: invalid line: #{i}" 
+                end
+            end
+
+            # --- Crop bottom, then measure how much was cropped.
+            sh "pnmcrop -white -bottom #{file}.pnm >#{file}.bottomcrop.pnm"
+            #raise Error, "`pnmcrop` command failed: #{result}" unless ::File.exist?(file + ".bottomcrop.pnm")
+
+            img_width_bottomcrop, img_height_bottomcrop = pnm_width_height("#{file}.bottomcrop.pnm")
+            bottomcrop = img_height - img_height_bottomcrop
+            
+            # --- Crop top and sides, then measure how much was cropped from the top.
+            sh "pnmcrop -white #{file}.bottomcrop.pnm > #{file}.crop.pnm"
+            #raise Error, "`pnmcrop` command failed: #{result}" unless ::File.exist?(file + ".crop.pnm")
+
+            cropped_img_width, cropped_img_height = pnm_width_height("#{file}.crop.pnm")
+            topcrop = img_height_bottomcrop - cropped_img_height
+
+            # --- Pad image with specific values on all four sides, in preparation for
+            #     downsampling.
+
+            # Calculate bottom padding.
+            snippet_depth = Integer(dimensions["snippetdepth"] + dimensions["pagemargin"] + 0.5) - bottomcrop
+            padded_snippet_depth = round_up(snippet_depth, oversample)
+            increase_snippet_depth = padded_snippet_depth - snippet_depth
+            bottom_padding = increase_snippet_depth
+            
+            # --- Next calculate top padding, which depends on bottom padding.
+
+            padded_img_height = round_up(cropped_img_height + bottom_padding,
+                oversample)
+            top_padding = padded_img_height - (cropped_img_height + bottom_padding)
+
+
+            # --- Calculate left and right side padding.  Distribute padding evenly.
+
+            padded_img_width = round_up(cropped_img_width, oversample)
+            left_padding = Integer((padded_img_width - cropped_img_width) / 2.0)
+            right_padding = (padded_img_width - cropped_img_width) - left_padding
+
+
+            # --- Pad the final image.
+            result = sh "pnmpad",
+                "-white",
+                "-bottom=#{bottom_padding}",
+                "-top=#{top_padding}",
+                "-left=#{left_padding}",
+                "-right=#{right_padding}",
+                "#{file}.crop.pnm",
+                ">#{file}.pad.pnm"
+
+            # --- Sanity check of final size.
+            final_pnm_width, final_pnm_height = pnm_width_height(file + ".pad.pnm")
+            raise Error, "#{final_pnm_width} is not a multiple of #{oversample}" unless final_pnm_width % oversample == 0
+            
+            raise "#{final_pnm_height} is not a multiple of #{oversample}" unless final_pnm_height % oversample == 0
+
+            # --- Convert PNM to PNG.
+
+            final_png_width  = final_pnm_width  / render_oversample
+            final_png_height = final_pnm_height / render_oversample
+
+            result = sh "cat #{file}.pad.pnm",
+                "| ppmtopgm",
+                "| pnmscale -reduce #{render_oversample}",
+                "| pnmgamma #{gamma}",
+                "| pnmtopng -compression 9",
+                "> #{file}.png"
+
+            raise Error, "Conversion to png failed: #{result}" unless ::File.exist?(file + ".png")
+
+            # Calculate html properties
+            html_img_width  = final_png_width  / display_oversample
+            html_img_height = final_png_height / display_oversample
+            html_img_vertical_align = sprintf("%.0f", -padded_snippet_depth / oversample) 
+            png_data_base64 = Base64.encode64(::File.open("#{file}.png") { |io| io.read }).chomp
+
+            ::File.open(cache_file, 'w') { |f| f.write(%{#{html_img_width},#{html_img_height},#{html_img_vertical_align},#{png_data_base64}}) }
+            if with_properties
+                return html_img_width, html_img_height, html_img_vertical_align, png_data_base64
+            else
+                ::File.read(file + ".png")
+            end
+        end
     end
 
     private
+      def self.sh_chdir(path, *args)  
+        origcommand = args * " "
+        return if origcommand == ""
+
+        command = origcommand
+        command.gsub! /(["\\])/, "\\$1"
+        command = %{/bin/sh -c "(#{command}) 2>&1"}
+
+        pid = spawn command, :chdir => path
+
+        result = Process::waitpid(pid)
+        exit_value = Integer($? >> 8), signal_num = Integer($? & 127), dumped_core = Integer($? & 128)
+        raise Error, "Failed #{result}: #{origcommand}. Exit value = #{exit_value}. Signal Num = #{signal_num}. Dumped core = #{dumped_core}" unless $?.success?
+
+        return result
+      end
+
       def self.sh(*args)
-        pid = spawn *args
-        Process::waitpid(pid)
+        origcommand = args * " "
+        return if origcommand == ""
+
+        command = origcommand
+        command.gsub! /(["\\])/, "\\$1"
+        command = %{/bin/sh -c "(#{command}) 2>&1"}
+
+        pid = spawn command
+        #pid = spawn *args
+        result = Process::waitpid(pid)
+        exit_value = $? >> 8, signal_num = $? & 127, dumped_core = $? & 128
+        raise Error, "Failed #{result}: #{origcommand}. Exit value = #{exit_value}. Signal Num = #{signal_num}. Dumped core = #{dumped_core}" unless $?.success?
+
+        return result
       end
+
+      def self.round_up(num, mod)
+        num + (num % mod == 0 ? 0 : (mod - (num % mod)))
+      end
+
+      def self.pnm_width_height(filename) 
+        raise Error, "#{filename} is not a .pnm file" if filename !~ /\.pnm$/ 
+
+        width = nil, height = nil
+        ::File.open(filename) do |file|
+          # Read first line
+          line = file.gets
+          begin 
+            line = file.gets # Read next line, skipping comments
+          end while line && line =~ /^#/
+
+          if line =~ /^(\d+)\s+(\d+)$/
+            width  = Integer($1)
+            height = Integer($2)
+          else 
+            raise Error, "#{filename}: couldn't read image size"
+          end
+        end
+
+        raise Error, "#{filename}: couldn't read image size" unless width && height
+
+        return width, height
+      end      
+
   end
 end

data/lib/gollum/wiki.rb

@@ -32,6 +32,10 @@ module Gollum
       # sanitization altogether.
       attr_writer :history_sanitization
 
+      # Hash for setting different default wiki options
+      # These defaults can be overridden by options passed directly to initialize()
+      attr_accessor :default_options
+
       # Gets the page class used by all instances of this Wiki.
       # Default: Gollum::Page.
       def page_class
@@ -107,6 +111,7 @@ module Gollum
     self.default_committer_email = 'anon@anon.com'
 
     self.default_ws_subs = ['_','-']
+    self.default_options = {}
 
     # The String base path to prefix to internal links. For example, when set
     # to "/wiki", the page "Hobbit" will be linked as "/wiki/Hobbit". Defaults
@@ -128,11 +133,16 @@ module Gollum
     # Gets the Array of chars to sub for ws in filenames.
     attr_reader :ws_subs
 
+    # Gets the boolean live preview value.
+    attr_reader :live_preview
+
     # Public: Initialize a new Gollum Repo.
     #
     # path    - The String path to the Git repository that holds the Gollum
     #           site.
     # options - Optional Hash:
+    #           :universal_toc - Table of contents on all pages.  Default: false
+    #           :live_preview  - Livepreview editing for markdown files. Default: true
     #           :base_path     - String base path for all Wiki links.
     #                            Default: "/"
     #           :page_class    - The page Class. Default: Gollum::Page
@@ -143,16 +153,19 @@ module Gollum
     #           :page_file_dir - String the directory in which all page files reside
     #           :ref - String the repository ref to retrieve pages from
     #           :ws_subs       - Array of chars to sub for ws in filenames.
+    #           :mathjax       - Set to false to disable mathjax.
     #
     # Returns a fresh Gollum::Repo.
     def initialize(path, options = {})
+      options = self.class.default_options.merge(options)
       if path.is_a?(GitAccess)
         options[:access] = path
         path             = path.path
       end
       @path          = path
+      @repo_is_bare  = options[:repo_is_bare]
       @page_file_dir = options[:page_file_dir]
-      @access        = options[:access]       || GitAccess.new(path, @page_file_dir)
+      @access        = options[:access]       || GitAccess.new(path, @page_file_dir, @repo_is_bare)
       @base_path     = options[:base_path]    || "/"
       @page_class    = options[:page_class]   || self.class.page_class
       @file_class    = options[:file_class]   || self.class.file_class
@@ -164,6 +177,9 @@ module Gollum
         self.class.default_ws_subs
       @history_sanitization = options[:history_sanitization] ||
         self.class.history_sanitization
+      @live_preview  = options.fetch(:live_preview, true)
+      @universal_toc = options.fetch(:universal_toc, false)
+      @mathjax = options[:mathjax] || true
     end
 
     # Public: check whether the wiki's git repo exists on the filesystem.
@@ -173,14 +189,27 @@ module Gollum
       @access.exist?
     end
 
-    # Public: Get the formatted page for a given page name.
+    # Public: Get the formatted page for a given page name, version, and dir.
+    #
+    # name    - The human or canonical String page name of the wiki page.
+    # version - The String version ID to find (default: @ref).
+    # dir     - The directory String relative to the repo.
+    #
+    # Returns a Gollum::Page or nil if no matching page was found.
+    def page(name, version = @ref, dir = nil)
+      version = @ref if version.nil?
+      @page_class.new(self).find(name, version, dir)
+    end
+
+    # Public: Convenience method instead of calling page(name, nil, dir).
     #
     # name    - The human or canonical String page name of the wiki page.
     # version - The String version ID to find (default: @ref).
+    # dir     - The directory String relative to the repo.
     #
     # Returns a Gollum::Page or nil if no matching page was found.
-    def page(name, version = @ref)
-      @page_class.new(self).find(name, version)
+    def paged(name, dir = nil, version = @ref)
+      page(name, version, dir)
     end
 
     # Public: Get the static file for a given name.
@@ -430,6 +459,15 @@ module Gollum
       tree_list(treeish || @ref)
     end
 
+    # Public: Lists all non-page files for this wiki.
+    #
+    # treeish - The String commit ID or ref to find  (default:  @ref)
+    #
+    # Returns an Array of Gollum::File instances.
+    def files(treeish = nil)
+      file_list(treeish || @ref)
+    end
+
     # Public: Returns the number of pages accessible from a commit
     #
     # ref - A String ref that is either a commit SHA or references one.
@@ -452,14 +490,26 @@ module Gollum
       args = [{}, '-i', '-c', query, @ref, '--']
       args << '--' << @page_file_dir if @page_file_dir
 
-      @repo.git.grep(*args).split("\n").map! do |line|
+      results = {}
+
+      @repo.git.grep(*args).split("\n").each do |line|
         result = line.split(':')
-        file_name = Gollum::Page.canonicalize_filename(::File.basename(result[1]))
+        result_1 = result[1]
+        file_name = result_1.chomp(::File.extname(result_1))
+        results[file_name] = result[2].to_i
+      end
+
+      # Use git ls-files '*query*' to search for file names. Grep only searches file content.
+      # Spaces are converted to dashes when saving pages to disk.
+      @repo.git.ls_files({}, "*#{ query.gsub(' ', '-') }*").split("\n").each do |line|
+        file_name = line.chomp(::File.extname(line))
+        # If there's not already a result for file_name then
+        # the value is nil and nil.to_i is 0.
+        results[file_name] = results[file_name].to_i + 1;
+      end
 
-        {
-          :count  => result[2].to_i,
-          :name   => file_name
-        }
+      results.map do |key,val|
+        { :count => val, :name => key }
       end
     end
 
@@ -527,6 +577,12 @@ module Gollum
     # Gets the markup class used by all instances of this Wiki.
     attr_reader :markup_classes
 
+    # Toggles display of universal table of contents
+    attr_reader :universal_toc
+
+    # Toggles mathjax.
+    attr_reader :mathjax
+
     # Normalize the data.
     #
     # data - The String data to be normalized.
@@ -563,6 +619,24 @@ module Gollum
       end
     end
 
+    # Fill an array with a list of files.
+    #
+    # ref - A String ref that is either a commit SHA or references one.
+    #
+    # Returns a flat Array of Gollum::File instances.
+    def file_list(ref)
+      if sha = @access.ref_to_sha(ref)
+        commit = @access.commit(sha)
+        tree_map_for(sha).inject([]) do |list, entry|
+          next list if entry.name.start_with?('_')
+          next list if @page_class.valid_page_name?(entry.name)
+          list << entry.file(self, commit)
+        end
+      else
+        []
+      end
+    end
+
     # Creates a reverse diff for the given SHAs on the given Gollum::Page.
     #
     # page   - The Gollum::Page to scope the patch to, or a String Path.
@@ -621,10 +695,16 @@ module Gollum
     # listing is cached based on its actual commit SHA.
     #
     # ref - A String ref that is either a commit SHA or references one.
+    # ignore_page_file_dir - Boolean, if true, searches all files within the git repo, regardless of dir/subdir
     #
     # Returns an Array of BlobEntry instances.
-    def tree_map_for(ref)
-      @access.tree(ref)
+    def tree_map_for(ref, ignore_page_file_dir=false)
+      if ignore_page_file_dir && !@page_file_dir.nil?
+        @root_access ||= GitAccess.new(path, nil, @repo_is_bare)
+        @root_access.tree(ref)
+      else
+        @access.tree(ref)
+      end
     rescue Grit::GitRuby::Repository::NoSuchShaFound
       []
     end