gollum 1.1.1 → 1.2.0

data/lib/gollum/markup.rb

@@ -11,12 +11,14 @@ module Gollum
     def initialize(page)
       @wiki    = page.wiki
       @name    = page.filename
-      @data    = page.raw_data
+      @data    = page.text_data
       @version = page.version.id
+      @format  = page.format
       @dir     = ::File.dirname(page.path)
       @tagmap  = {}
       @codemap = {}
       @texmap  = {}
+      @premap  = {}
     end
 
     # Render the content with Gollum wiki syntax on top of the file's own
@@ -27,10 +29,11 @@ module Gollum
     #
     # Returns the formatted String content.
     def render(no_follow = false)
-      sanitize_options = no_follow   ? 
-        HISTORY_SANITIZATION_OPTIONS : 
-        SANITIZATION_OPTIONS
-      data = extract_tex(@data)
+      sanitize = no_follow ?
+        @wiki.history_sanitizer :
+        @wiki.sanitizer
+
+      data = extract_tex(@data.dup)
       data = extract_code(data)
       data = extract_tags(data)
       begin
@@ -43,12 +46,21 @@ module Gollum
       end
       data = process_tags(data)
       data = process_code(data)
-      data = Sanitize.clean(data, sanitize_options)
+      if sanitize || block_given?
+        doc  = Nokogiri::HTML::DocumentFragment.parse(data)
+        doc  = sanitize.clean_node!(doc) if sanitize
+        yield doc if block_given?
+        data = doc_to_html(doc)
+      end
       data = process_tex(data)
       data.gsub!(/<p><\/p>/, '')
       data
     end
 
+    def doc_to_html(doc)
+      doc.to_xhtml(:save_with => Nokogiri::XML::Node::SaveOptions::AS_XHTML)
+    end
+
     #########################################################################
     #
     # TeX
@@ -105,49 +117,57 @@ module Gollum
     #
     # Returns the placeholder'd String data.
     def extract_tags(data)
-      data.gsub(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
+      data.gsub!(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
         if $1 == "'" && $3 != "'"
           "[[#{$2}]]#{$3}"
         elsif $2.include?('][')
-          $&
+          if $2[0..4] == 'file:'
+            pre = $1
+            post = $3
+            parts = $2.split('][')
+            parts[0][0..4] = ""
+            link = "#{parts[1]}|#{parts[0].sub(/\.org/,'')}"
+            id = Digest::SHA1.hexdigest(link)
+            @tagmap[id] = link
+            "#{pre}#{id}#{post}"
+          else
+            $&
+          end
         else
           id = Digest::SHA1.hexdigest($2)
           @tagmap[id] = $2
           "#{$1}#{id}#{$3}"
         end
       end
+      data
     end
 
     # Process all tags from the tagmap and replace the placeholders with the
     # final markup.
     #
     # data      - The String data (with placeholders).
-    # no_follow - Boolean that determines if rel="nofollow" is added to all
-    #             <a> tags.
     #
     # Returns the marked up String data.
-    def process_tags(data, no_follow = false)
+    def process_tags(data)
       @tagmap.each do |id, tag|
-        data.gsub!(id, process_tag(tag, no_follow))
+        data.gsub!(id, process_tag(tag))
       end
       data
     end
 
     # Process a single tag into its final HTML form.
     #
-    # tag       - The String tag contents (the stuff inside the double 
+    # tag       - The String tag contents (the stuff inside the double
     #             brackets).
-    # no_follow - Boolean that determines if rel="nofollow" is added to all
-    #             <a> tags.
     #
     # Returns the String HTML version of the tag.
-    def process_tag(tag, no_follow = false)
+    def process_tag(tag)
       if html = process_image_tag(tag)
         html
-      elsif html = process_file_link_tag(tag, no_follow)
+      elsif html = process_file_link_tag(tag)
         html
       else
-        process_page_link_tag(tag, no_follow)
+        process_page_link_tag(tag)
       end
     end
 
@@ -159,6 +179,8 @@ module Gollum
     #   if it is not.
     def process_image_tag(tag)
       parts = tag.split('|')
+      return if parts.size.zero?
+
       name  = parts[0].strip
       path  = if file = find_file(name)
         ::File.join @wiki.base_path, file.path
@@ -240,15 +262,15 @@ module Gollum
 
     # Attempt to process the tag as a file link tag.
     #
-    # tag       - The String tag contents (the stuff inside the double 
+    # tag       - The String tag contents (the stuff inside the double
     #             brackets).
-    # no_follow - Boolean that determines if rel="nofollow" is added to all
-    #             <a> tags.
     #
     # Returns the String HTML if the tag is a valid file link tag or nil
     #   if it is not.
-    def process_file_link_tag(tag, no_follow = false)
+    def process_file_link_tag(tag)
       parts = tag.split('|')
+      return if parts.size.zero?
+
       name  = parts[0].strip
       path  = parts[1] && parts[1].strip
       path  = if path && file = find_file(path)
@@ -259,49 +281,42 @@ module Gollum
         nil
       end
 
-      tag = if name && path && file
+      if name && path && file
         %{<a href="#{::File.join @wiki.base_path, file.path}">#{name}</a>}
       elsif name && path
         %{<a href="#{path}">#{name}</a>}
       else
         nil
       end
-      if tag && no_follow
-        tag.sub! /^<a/, '<a ref="nofollow"'
-      end
-      tag
     end
 
     # Attempt to process the tag as a page link tag.
     #
-    # tag       - The String tag contents (the stuff inside the double 
+    # tag       - The String tag contents (the stuff inside the double
     #             brackets).
-    # no_follow - Boolean that determines if rel="nofollow" is added to all
-    #             <a> tags.
     #
     # Returns the String HTML if the tag is a valid page link tag or nil
     #   if it is not.
-    def process_page_link_tag(tag, no_follow = false)
+    def process_page_link_tag(tag)
       parts = tag.split('|')
-      name  = parts[0].strip
-      cname = Page.cname((parts[1] || parts[0]).strip)
-      tag = if name =~ %r{^https?://} && parts[1].nil?
+      parts.reverse! if @format == :mediawiki
+
+      name, page_name = *parts.compact.map(&:strip)
+      cname = @wiki.page_class.cname(page_name || name)
+
+      if name =~ %r{^https?://} && page_name.nil?
         %{<a href="#{name}">#{name}</a>}
       else
         presence    = "absent"
         link_name   = cname
         page, extra = find_page_from_name(cname)
         if page
-          link_name = Page.cname(page.name)
+          link_name = @wiki.page_class.cname(page.name)
           presence  = "present"
         end
         link = ::File.join(@wiki.base_path, CGI.escape(link_name))
         %{<a class="internal #{presence}" href="#{link}#{extra}">#{name}</a>}
       end
-      if tag && no_follow
-        tag.sub! /^<a/, '<a ref="nofollow"'
-      end
-      tag
     end
 
     # Find the given file in the repo.
@@ -323,7 +338,7 @@ module Gollum
     #
     # cname - The String canonical page name.
     #
-    # Returns a Gollum::Page instance if a page is found, or an Array of 
+    # Returns a Gollum::Page instance if a page is found, or an Array of
     # [Gollum::Page, String extra] if a page without the extra anchor data
     # is found.
     def find_page_from_name(cname)
@@ -347,11 +362,15 @@ module Gollum
     #
     # Returns the placeholder'd String data.
     def extract_code(data)
-      data.gsub(/^``` ?([^\r\n]+)?\r?\n(.+?)\r?\n```\r?$/m) do
-        id = Digest::SHA1.hexdigest($2)
-        @codemap[id] = { :lang => $1, :code => $2 }
+      data.gsub!(/^``` ?([^\r\n]+)?\r?\n(.+?)\r?\n```\r?$/m) do
+        id     = Digest::SHA1.hexdigest($2)
+        cached = check_cache(:code, id)
+        @codemap[id] = cached   ?
+          { :output => cached } :
+          { :lang => $1, :code => $2 }
         id
       end
+      data
     end
 
     # Process all code from the codemap and replace the placeholders with the
@@ -361,18 +380,59 @@ module Gollum
     #
     # Returns the marked up String data.
     def process_code(data)
+      return data if data.nil? || data.size.zero? || @codemap.size.zero?
+
+      blocks    = []
       @codemap.each do |id, spec|
+        next if spec[:output] # cached
+
         code = spec[:code]
         if code.lines.all? { |line| line =~ /\A\r?\n\Z/ || line =~ /^(  |\t)/ }
           code.gsub!(/^(  |\t)/m, '')
         end
-        if lang = spec[:lang]
-          data.gsub!(id, Gollum::Albino.new(code, lang).colorize)
-        else
-          data.gsub!(id, "<pre><code>#{CGI.escapeHTML(code)}</code></pre>")
+
+        blocks << [spec[:lang], code]
+      end
+
+      highlighted = begin
+        blocks.size.zero? ? [] : Gollum::Albino.colorize(blocks)
+      rescue ::Albino::ShellArgumentError, ::Albino::TimeoutExceeded,
+               ::Albino::MaximumOutputExceeded
+        []
+      end
+
+      @codemap.each do |id, spec|
+        body = spec[:output] || begin
+          if (body = highlighted.shift.to_s).size > 0
+            update_cache(:code, id, body)
+            body
+          else
+            "<pre><code>#{CGI.escapeHTML(spec[:code])}</code></pre>"
+          end
         end
+        data.gsub!(id, body)
       end
+
       data
     end
+
+    # Hook for getting the formatted value of extracted tag data.
+    #
+    # type - Symbol value identifying what type of data is being extracted.
+    # id   - String SHA1 hash of original extracted tag data.
+    #
+    # Returns the String cached formatted data, or nil.
+    def check_cache(type, id)
+    end
+
+    # Hook for caching the formatted value of extracted tag data.
+    #
+    # type - Symbol value identifying what type of data is being extracted.
+    # id   - String SHA1 hash of original extracted tag data.
+    # data - The String formatted value to be cached.
+    #
+    # Returns nothing.
+    def update_cache(type, id, data)
+    end
   end
 end

data/lib/gollum/page.rb

@@ -4,15 +4,16 @@ module Gollum
 
     Wiki.page_class = self
 
-    VALID_PAGE_RE = /^(.+)\.(md|mkdn?|mdown|markdown|textile|rdoc|org|creole|re?st(\.txt)?|asciidoc|pod)$/i
-    FORMAT_NAMES = { :markdown => "Markdown",
-                     :textile  => "Textile",
-                     :rdoc     => "RDoc",
-                     :org      => "Org-mode",
-                     :creole   => "Creole",
-                     :rest     => "reStructuredText",
-                     :asciidoc => "AsciiDoc",
-                     :pod      => "Pod" }
+    VALID_PAGE_RE = /^(.+)\.(md|mkdn?|mdown|markdown|textile|rdoc|org|creole|re?st(\.txt)?|asciidoc|pod|(media)?wiki)$/i
+    FORMAT_NAMES = { :markdown  => "Markdown",
+                     :textile   => "Textile",
+                     :rdoc      => "RDoc",
+                     :org       => "Org-mode",
+                     :creole    => "Creole",
+                     :rest      => "reStructuredText",
+                     :asciidoc  => "AsciiDoc",
+                     :mediawiki => "MediaWiki",
+                     :pod       => "Pod" }
 
     # Sets a Boolean determing whether this page is a historical version.
     #
@@ -40,6 +41,40 @@ module Gollum
       filename =~ /^_/ ? false : match
     end
 
+    # Public: The format of a given filename.
+    #
+    # filename - The String filename.
+    #
+    # Returns the Symbol format of the page. One of:
+    #   [ :markdown | :textile | :rdoc | :org | :rest | :asciidoc | :pod |
+    #     :roff ]
+    def self.format_for(filename)
+      case filename.to_s
+        when /\.(md|mkdn?|mdown|markdown)$/i
+          :markdown
+        when /\.(textile)$/i
+          :textile
+        when /\.(rdoc)$/i
+          :rdoc
+        when /\.(org)$/i
+          :org
+        when /\.(creole)$/i
+          :creole
+        when /\.(re?st(\.txt)?)$/i
+          :rest
+        when /\.(asciidoc)$/i
+          :asciidoc
+        when /\.(pod)$/i
+          :pod
+        when /\.(\d)$/i
+          :roff
+        when /\.(media)?wiki$/i
+          :mediawiki
+        else
+          nil
+      end
+    end
+
     # Reusable filter to turn a filename (without path) into a canonical name.
     # Strips extension, converts spaces to dashes.
     #
@@ -55,7 +90,7 @@ module Gollum
     # Returns a newly initialized Gollum::Page.
     def initialize(wiki)
       @wiki = wiki
-      @blob = nil
+      @blob = @footer = @sidebar = nil
     end
 
     # Public: The on-disk filename of the page including extension.
@@ -65,7 +100,7 @@ module Gollum
       @blob && @blob.name
     end
 
-    # Public: The canonical page name without extension, and dashes converted 
+    # Public: The canonical page name without extension, and dashes converted
     # to spaces.
     #
     # Returns the String name.
@@ -101,7 +136,7 @@ module Gollum
         Sanitize.clean(header.to_html)
       else
         Sanitize.clean(name)
-      end
+      end.strip
     end
 
     # Public: The path of the page within the repo.
@@ -116,11 +151,24 @@ module Gollum
       @blob && @blob.data
     end
 
+    # Public: A text data encoded in specified encoding.
+    #
+    # encoding - An Encoding or nil
+    #
+    # Returns a character encoding aware String.
+    def text_data(encoding=nil)
+      if raw_data.respond_to?(:encoding)
+        raw_data.force_encoding(encoding || Encoding::UTF_8)
+      else
+        raw_data
+      end
+    end
+
     # Public: The formatted contents of the page.
     #
     # Returns the String data.
-    def formatted_data
-      @blob && Gollum::Markup.new(self).render(historical?)
+    def formatted_data(&block)
+      @blob && @wiki.markup_class.new(self).render(historical?, &block)
     end
 
     # Public: The format of the page.
@@ -129,28 +177,7 @@ module Gollum
     #   [ :markdown | :textile | :rdoc | :org | :rest | :asciidoc | :pod |
     #     :roff ]
     def format
-      case @blob.name
-        when /\.(md|mkdn?|mdown|markdown)$/i
-          :markdown
-        when /\.(textile)$/i
-          :textile
-        when /\.(rdoc)$/i
-          :rdoc
-        when /\.(org)$/i
-          :org
-        when /\.(creole)$/i
-          :creole
-        when /\.(re?st(\.txt)?)$/i
-          :rest
-        when /\.(asciidoc)$/i
-          :asciidoc
-        when /\.(pod)$/i
-          :pod
-        when /\.(\d)$/i
-          :roff
-        else
-          nil
-      end
+      self.class.format_for(@blob.name)
     end
 
     # Public: The current version of the page.
@@ -163,7 +190,7 @@ module Gollum
     # options - The options Hash:
     #           :page     - The Integer page number (default: 1).
     #           :per_page - The Integer max count of items to return.
-    #           :follow   - Follow's a file across renames, but falls back 
+    #           :follow   - Follow's a file across renames, but falls back
     #                       to a slower Grit native call.  (default: false)
     #
     # Returns an Array of Grit::Commit.
@@ -183,22 +210,17 @@ module Gollum
     #
     # Returns the footer Page or nil if none exists.
     def footer
-      return nil if page_match('_Footer', self.filename)
-
-      dirs = self.path.split('/')
-      dirs.pop
-      map = @wiki.tree_map_for(self.version.id)
-      while !dirs.empty?
-        if page = find_page_in_tree(map, '_Footer', dirs.join('/'))
-          return page
-        end
-        dirs.pop
-      end
+      @footer ||= find_sub_page(:footer)
+    end
 
-      find_page_in_tree(map, '_Footer', '')
+    # Public: The sidebar Page.
+    #
+    # Returns the sidebar Page or nil if none exists.
+    def sidebar
+      @sidebar ||= find_sub_page(:sidebar)
     end
 
-    # Gets a Boolean determining whether this page is a historical version.  
+    # Gets a Boolean determining whether this page is a historical version.
     # Historical pages are pulled using exact SHA hashes and format all links
     # with rel="nofollow"
     #
@@ -236,14 +258,15 @@ module Gollum
     # Returns the String extension (no leading period).
     def self.format_to_ext(format)
       case format
-        when :markdown then 'md'
-        when :textile  then 'textile'
-        when :rdoc     then 'rdoc'
-        when :org      then 'org'
-        when :creole   then 'creole'
-        when :rest     then 'rest'
-        when :asciidoc then 'asciidoc'
-        when :pod      then 'pod'
+        when :markdown  then 'md'
+        when :textile   then 'textile'
+        when :rdoc      then 'rdoc'
+        when :org       then 'org'
+        when :creole    then 'creole'
+        when :rest      then 'rest'
+        when :asciidoc  then 'asciidoc'
+        when :pod       then 'pod'
+        when :mediawiki then 'mediawiki'
       end
     end
 
@@ -270,11 +293,11 @@ module Gollum
     #
     # Returns a Gollum::Page or nil if the page could not be found.
     def find(name, version)
-      map = @wiki.tree_map_for(version)
+      map = @wiki.tree_map_for(version.to_s)
       if page = find_page_in_tree(map, name)
-        sha = @wiki.ref_map[version] || version
-        page.version    = Grit::Commit.create(@wiki.repo, :id => sha)
-        page.historical = sha == version
+        page.version    = version.is_a?(Grit::Commit) ?
+          version : @wiki.commit_for(version)
+        page.historical = page.version.to_s == version.to_s
         page
       end
     rescue Grit::GitRuby::Repository::NoSuchShaFound
@@ -285,11 +308,11 @@ module Gollum
     # map         - The Array tree map from Wiki#tree_map.
     # name        - The canonical String page name.
     # checked_dir - Optional String of the directory a matching page needs
-    #               to be in.  The string should 
+    #               to be in.  The string should
     #
     # Returns a Gollum::Page or nil if the page could not be found.
     def find_page_in_tree(map, name, checked_dir = nil)
-      return nil if name.to_s.empty?
+      return nil if !map || name.to_s.empty?
       if checked_dir = BlobEntry.normalize_dir(checked_dir)
         checked_dir.downcase!
       end
@@ -310,9 +333,9 @@ module Gollum
     # path - The String directory path of the page file.
     #
     # Returns the populated Gollum::Page.
-    def populate(blob, path)
+    def populate(blob, path=nil)
       @blob = blob
-      @path = (path + '/' + blob.name)[1..-1]
+      @path = "#{path}/#{blob.name}"[1..-1]
       self
     end
 
@@ -343,5 +366,29 @@ module Gollum
         false
       end
     end
+
+    # Loads a sub page.  Sub page nanes (footers) are prefixed with
+    # an underscore to distinguish them from other Pages.
+    #
+    # name - String page name.
+    #
+    # Returns the Page or nil if none exists.
+    def find_sub_page(name)
+      return nil if self.filename =~ /^_/
+      name = "_#{name.to_s.capitalize}"
+      return nil if page_match(name, self.filename)
+
+      dirs = self.path.split('/')
+      dirs.pop
+      map = @wiki.tree_map_for(self.version.id)
+      while !dirs.empty?
+        if page = find_page_in_tree(map, name, dirs.join('/'))
+          return page
+        end
+        dirs.pop
+      end
+
+      find_page_in_tree(map, name, '')
+    end
   end
-end
+end