tecnh-gollum 1.0.2.auth

data/lib/gollum/markup.rb

@@ -0,0 +1,343 @@
+require 'digest/sha1'
+
+module Gollum
+  class Markup
+    # Initialize a new Markup object.
+    #
+    # page - The Gollum::Page.
+    #
+    # Returns a new Gollum::Markup object, ready for rendering.
+    def initialize(page)
+      @wiki    = page.wiki
+      @name    = page.filename
+      @data    = page.raw_data
+      @version = page.version.id
+      @dir     = ::File.dirname(page.path)
+      @tagmap  = {}
+      @codemap = {}
+      @texmap  = {}
+    end
+
+    # Render the content with Gollum wiki syntax on top of the file's own
+    # markup language.
+    #
+    # Returns the formatted String content.
+    def render
+      data = extract_tex(@data)
+      data = extract_code(data)
+      data = extract_tags(data)
+      begin
+        data = GitHub::Markup.render(@name, data)
+        if data.nil?
+          raise "There was an error converting #{@name} to HTML."
+        end
+      rescue Object => e
+        data = %{<p class="gollum-error">#{e.message}</p>}
+      end
+      data = process_code(data)
+      data = Sanitize.clean(data, SANITIZATION_OPTIONS)
+      data = process_tags(data)
+      data = process_tex(data)
+      data = data.gsub(/<p><\/p>/, '')
+      data
+    end
+
+    #########################################################################
+    #
+    # TeX
+    #
+    #########################################################################
+
+    # Extract all TeX into the texmap and replace with placeholders.
+    #
+    # data - The raw String data.
+    #
+    # Returns the placeholder'd String data.
+    def extract_tex(data)
+      data.gsub(/\\\[\s*(.*?)\s*\\\]/m) do
+        id = Digest::SHA1.hexdigest($1)
+        @texmap[id] = [:block, $1]
+        id
+      end.gsub(/\\\(\s*(.*?)\s*\\\)/m) do
+        id = Digest::SHA1.hexdigest($1)
+        @texmap[id] = [:inline, $1]
+        id
+      end
+    end
+
+    # Process all TeX from the texmap and replace the placeholders with the
+    # final markup.
+    #
+    # data - The String data (with placeholders).
+    #
+    # Returns the marked up String data.
+    def process_tex(data)
+      @texmap.each do |id, spec|
+        type, tex = *spec
+        out =
+        case type
+          when :block
+            %{<script type="math/tex; mode=display">#{tex}</script>}
+          when :inline
+            %{<script type="math/tex">#{tex}</script>}
+        end
+        data.gsub!(id, out)
+      end
+      data
+    end
+
+    #########################################################################
+    #
+    # Tags
+    #
+    #########################################################################
+
+    # Extract all tags into the tagmap and replace with placeholders.
+    #
+    # data - The raw String data.
+    #
+    # Returns the placeholder'd String data.
+    def extract_tags(data)
+      data.gsub(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
+        if $1 == "'" && $3 != "'"
+          "[[#{$2}]]#{$3}"
+        elsif $2.include?('][')
+          $&
+        else
+          id = Digest::SHA1.hexdigest($2)
+          @tagmap[id] = $2
+          "#{$1}#{id}#{$3}"
+        end
+      end
+    end
+
+    # Process all tags from the tagmap and replace the placeholders with the
+    # final markup.
+    #
+    # data - The String data (with placeholders).
+    #
+    # Returns the marked up String data.
+    def process_tags(data)
+      @tagmap.each do |id, tag|
+        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 brackets).
+    #
+    # Returns the String HTML version of the tag.
+    def process_tag(tag)
+      if html = process_image_tag(tag)
+        return html
+      elsif html = process_gist_link_tag(tag)
+        return html
+      elsif html = process_file_link_tag(tag)
+        return html
+      else
+        return process_page_link_tag(tag)
+      end
+    end
+
+    # Attempt to process the tag as an image tag.
+    #
+    # tag - The String tag contents (the stuff inside the double brackets).
+    #
+    # Returns the String HTML if the tag is a valid image tag or nil
+    #   if it is not.
+    def process_image_tag(tag)
+      parts = tag.split('|')
+      name  = parts[0].strip
+      path  = if file = find_file(name)
+        ::File.join @wiki.base_path, file.path
+      elsif name =~ /^https?:\/\/.+(jpg|png|gif|svg|bmp)$/
+        name
+      end
+
+      if path
+        opts = parse_image_tag_options(tag)
+
+        containered = false
+
+        classes = [] # applied to whatever the outermost container is
+        attrs   = [] # applied to the image
+
+        align = opts['align']
+        if opts['float']
+          containered = true
+          align ||= 'left'
+          if %w{left right}.include?(align)
+            classes << "float-#{align}"
+          end
+        elsif %w{top texttop middle absmiddle bottom absbottom baseline}.include?(align)
+          attrs << %{align="#{align}"}
+        elsif align
+          if %w{left center right}.include?(align)
+            containered = true
+            classes << "align-#{align}"
+          end
+        end
+
+        if width = opts['width']
+          if width =~ /^\d+(\.\d+)?(em|px)$/
+            attrs << %{width="#{width}"}
+          end
+        end
+
+        if height = opts['height']
+          if height =~ /^\d+(\.\d+)?(em|px)$/
+            attrs << %{height="#{height}"}
+          end
+        end
+
+        if alt = opts['alt']
+          attrs << %{alt="#{alt}"}
+        end
+
+        attr_string = attrs.size > 0 ? attrs.join(' ') + ' ' : ''
+
+        if opts['frame'] || containered
+          classes << 'frame' if opts['frame']
+          %{<span class="#{classes.join(' ')}">} +
+          %{<span>} +
+          %{<img src="#{path}" #{attr_string}/>} +
+          (alt ? %{<span>#{alt}</span>} : '') +
+          %{</span>} +
+          %{</span>}
+        else
+          %{<img src="#{path}" #{attr_string}/>}
+        end
+      end
+    end
+
+    # Parse any options present on the image tag and extract them into a
+    # Hash of option names and values.
+    #
+    # tag - The String tag contents (the stuff inside the double brackets).
+    #
+    # Returns the options Hash:
+    #   key - The String option name.
+    #   val - The String option value or true if it is a binary option.
+    def parse_image_tag_options(tag)
+      tag.split('|')[1..-1].inject({}) do |memo, attr|
+        parts = attr.split('=').map { |x| x.strip }
+        memo[parts[0]] = (parts.size == 1 ? true : parts[1])
+        memo
+      end
+    end
+
+    # Attempt to process the tag as a gist link tag.
+    #
+    # tag - The String tag contents (the stuff inside the double brackets).
+    #
+    # Returns the String HTML if the tag is a valid gist link tag or nil
+    #   if it is not.
+    def process_gist_link_tag(tag)
+      tag.sub!(/^(?:https?:\/\/)?(gist\.github\.com\/\d+)(?:\.js)?((?:\?file=\w+(?:\.\w+)*)?)$/, '<script src="http://\1.js\2"></script>')
+    end
+
+    # Attempt to process the tag as a file link tag.
+    #
+    # tag - The String tag contents (the stuff inside the double brackets).
+    #
+    # 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)
+      parts = tag.split('|')
+      name  = parts[0].strip
+      path  = parts[1] && parts[1].strip
+      path  = if path && file = find_file(path)
+        ::File.join @wiki.base_path, file.path
+      elsif path =~ %r{^https?://}
+        path
+      else
+        nil
+      end
+
+      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
+    end
+
+    # Attempt to process the tag as a page link tag.
+    #
+    # tag - The String tag contents (the stuff inside the double brackets).
+    #
+    # 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)
+      parts = tag.split('|')
+      name  = parts[0].strip
+      cname = Page.cname((parts[1] || parts[0]).strip)
+      if name =~ %r{^https?://} && parts[1].nil?
+        %{<a href="#{name}">#{name}</a>}
+      else
+        if page = @wiki.page(cname)
+          link = ::File.join(@wiki.base_path, Page.cname(page.name))
+          presence = "present"
+        else
+          link = ::File.join(@wiki.base_path, cname)
+          presence = "absent"
+        end
+        %{<a class="internal #{presence}" href="#{link}">#{name}</a>}
+      end
+    end
+
+    # Find the given file in the repo.
+    #
+    # name - The String absolute or relative path of the file.
+    #
+    # Returns the Gollum::File or nil if none was found.
+    def find_file(name)
+      if name =~ /^\//
+        @wiki.file(name[1..-1], @version)
+      else
+        path = @dir == '.' ? name : ::File.join(@dir, name)
+        @wiki.file(path, @version)
+      end
+    end
+
+    #########################################################################
+    #
+    # Code
+    #
+    #########################################################################
+
+    # Extract all code blocks into the codemap and replace with placeholders.
+    #
+    # data - The raw String data.
+    #
+    # Returns the placeholder'd String data.
+    def extract_code(data)
+      data.gsub(/^``` ?(.+?)\r?\n(.+?)\r?\n```\r?$/m) do
+        id = Digest::SHA1.hexdigest($2)
+        @codemap[id] = { :lang => $1, :code => $2 }
+        id
+      end
+    end
+
+    # Process all code from the codemap and replace the placeholders with the
+    # final HTML.
+    #
+    # data - The String data (with placeholders).
+    #
+    # Returns the marked up String data.
+    def process_code(data)
+      @codemap.each do |id, spec|
+        lang = spec[:lang]
+        code = spec[:code]
+        if code.lines.all? { |line| line =~ /\A\r?\n\Z/ || line =~ /^(  |\t)/ }
+          code.gsub!(/^(  |\t)/m, '')
+        end
+        data.gsub!(id, Gollum::Albino.new(code, lang).colorize)
+      end
+      data
+    end
+  end
+end

data/lib/gollum/page.rb

@@ -0,0 +1,356 @@
+module Gollum
+  class Page
+    include Pagination
+
+    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" }
+
+    # Checks if a filename has a valid extension understood by GitHub::Markup.
+    #
+    # filename - String filename, like "Home.md".
+    #
+    # Returns the matching String basename of the file without the extension.
+    def self.valid_filename?(filename)
+      filename && filename.to_s =~ VALID_PAGE_RE && $1
+    end
+
+    # Checks if a filename has a valid extension understood by GitHub::Markup.
+    # Also, checks if the filename has no "_" in the front (such as
+    # _Footer.md).
+    #
+    # filename - String filename, like "Home.md".
+    #
+    # Returns the matching String basename of the file without the extension.
+    def self.valid_page_name?(filename)
+      match = valid_filename?(filename)
+      filename =~ /^_/ ? false : match
+    end
+
+    # Reusable filter to turn a filename (without path) into a canonical name.
+    # Strips extension, converts spaces to dashes.
+    #
+    # Returns the filtered String.
+    def self.canonicalize_filename(filename)
+      filename.split('.')[0..-2].join('.').gsub('-', ' ')
+    end
+
+    # Public: Initialize a page.
+    #
+    # wiki - The Gollum::Wiki in question.
+    #
+    # Returns a newly initialized Gollum::Page.
+    def initialize(wiki)
+      @wiki = wiki
+      @blob = nil
+    end
+
+    # Public: The on-disk filename of the page including extension.
+    #
+    # Returns the String name.
+    def filename
+      @blob && @blob.name
+    end
+
+    # Public: The canonical page name without extension, and dashes converted 
+    # to spaces.
+    #
+    # Returns the String name.
+    def name
+      self.class.canonicalize_filename(filename)
+    end
+
+    # Public: If the first element of a formatted page is an <h1> tag it can
+    # be considered the title of the page and used in the display. If the
+    # first element is NOT an <h1> tag, the title will be constructed from the
+    # filename by stripping the extension and replacing any dashes with
+    # spaces.
+    #
+    # Returns the fully sanitized String title.
+    def title
+      doc = Nokogiri::HTML(%{<div id="gollum-root">} + self.formatted_data + %{</div>})
+
+      header =
+      case self.format
+        when :asciidoc
+          doc.css("div#gollum-root > div#header > h1:first-child")
+        when :org
+          doc.css("div#gollum-root > p.title:first-child")
+        when :pod
+          doc.css("div#gollum-root > a.dummyTopAnchor:first-child + h1")
+        when :rest
+          doc.css("div#gollum-root > div > div > h1:first-child")
+        else
+          doc.css("div#gollum-root > h1:first-child")
+      end
+
+      if !header.empty?
+        Sanitize.clean(header.to_html)
+      else
+        Sanitize.clean(name)
+      end
+    end
+
+    # Public: The path of the page within the repo.
+    #
+    # Returns the String path.
+    attr_reader :path
+
+    # Public: The raw contents of the page.
+    #
+    # Returns the String data.
+    def raw_data
+      @blob && @blob.data
+    end
+
+    # Public: The formatted contents of the page.
+    #
+    # Returns the String data.
+    def formatted_data
+      @blob && Gollum::Markup.new(self).render
+    end
+
+    # Public: The format of the page.
+    #
+    # Returns the Symbol format of the page. One of:
+    #   [ :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
+    end
+
+    # Public: The current version of the page.
+    #
+    # Returns the Grit::Commit.
+    attr_reader :version
+
+    # Public: All of the versions that have touched the Page.
+    #
+    # 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 
+    #                       to a slower Grit native call.  (default: false)
+    #
+    # Returns an Array of Grit::Commit.
+    def versions(options = {})
+      if options[:follow]
+        options[:pretty] = 'raw'
+        options.delete :max_count
+        options.delete :skip
+        log = @wiki.repo.git.native "log", options, "master", "--", @path
+        Grit::Commit.list_from_string(@wiki.repo, log)
+      else
+        @wiki.repo.log('master', @path, log_pagination_options(options))
+      end
+    end
+
+    # Public: The footer Page.
+    #
+    # 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_this_tree(map, dirs.join('/'), '_Footer')
+          return page
+        end
+        dirs.pop
+      end
+
+      find_page_in_this_tree(map, '', '_Footer')
+    end
+
+    #########################################################################
+    #
+    # Class Methods
+    #
+    #########################################################################
+
+    # Convert a human page name into a canonical page name.
+    #
+    # name - The String human page name.
+    #
+    # Examples
+    #
+    #   Page.cname("Bilbo Baggins")
+    #   # => 'Bilbo-Baggins'
+    #
+    # Returns the String canonical name.
+    def self.cname(name)
+      name.gsub(%r{[ /<>]}, '-')
+    end
+
+    # Convert a format Symbol into an extension String.
+    #
+    # format - The format Symbol.
+    #
+    # 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'
+      end
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # The underlying wiki repo.
+    #
+    # Returns the Gollum::Wiki containing the page.
+    attr_reader :wiki
+
+    # Set the Grit::Commit version of the page.
+    #
+    # Returns nothing.
+    attr_writer :version
+
+    # Find a page in the given Gollum repo.
+    #
+    # name    - The human or canonical String page name to find.
+    # version - The String version ID to find.
+    #
+    # Returns a Gollum::Page or nil if the page could not be found.
+    def find(name, version)
+      map = @wiki.tree_map_for(version)
+      if page = find_page_in_tree(map, name)
+        sha = @wiki.ref_map[version] || version
+        page.version = Grit::Commit.create(@wiki.repo, :id => sha)
+        page
+      end
+    rescue Grit::GitRuby::Repository::NoSuchShaFound
+    end
+    # Find a page in a given tree.
+    #
+    # map  - The Array tree map from Wiki#tree_map.
+    # name - The canonical String page name.
+    #
+    # Returns a Gollum::Page or nil if the page could not be found.
+    def find_page_in_tree(map, name)
+      map.each do |(tree_name, blob_sha)|
+        blob_name = ::File.basename(tree_name)
+        if page_match(name, blob_name)
+          dir  = ::File.dirname(tree_name)
+          blob = Grit::Blob.create(@wiki.repo, :id => blob_sha, :name => blob_name)
+          dir.sub! /(^\/)|(^\.$)/, ''
+          dir = "/#{dir}" if !dir.empty?
+          return self.class.new(@wiki).populate(blob, dir)
+        end
+      end
+
+      return nil # nothing was found
+    end
+
+    # Find a page in a given tree without recursing into subtrees.
+    #
+    # map  - The Array tree map from Wiki#tree_map.
+    # dir  - The String path of the given Grit::Tree.
+    # name - The canonical String page name.
+    #
+    # Returns a Gollum::Page or nil if the page could not be found.
+    def find_page_in_this_tree(map, dir, name)
+      checked = dir.downcase
+      map.each do |(full_name, blob_sha)|
+        dir_name  = ::File.dirname(full_name)
+        if dir_name == '.'
+          dir_name = ''
+        else
+          dir_name.downcase!
+        end
+        blob_name = ::File.basename(full_name)
+        
+        if checked == dir_name && page_match(name, blob_name)
+          path = dir == '' ? '' : ::File.join('/', dir)
+          blob = Grit::Blob.create(@wiki.repo, :id => blob_sha, :name => blob_name)
+          page = self.class.new(@wiki).populate(blob, path)
+          page.version = self.version
+          return page
+        end
+      end
+
+      return nil # nothing was found
+    end
+
+    # Populate the Page with information from the Blob.
+    #
+    # blob - The Grit::Blob that contains the info.
+    # path - The String directory path of the page file.
+    #
+    # Returns the populated Gollum::Page.
+    def populate(blob, path)
+      @blob = blob
+      @path = (path + '/' + blob.name)[1..-1]
+      self
+    end
+
+    # The full directory path for the given tree.
+    #
+    # treemap - The Hash treemap containing parentage information.
+    # tree    - The Grit::Tree for which to compute the path.
+    #
+    # Returns the String path.
+    def tree_path(treemap, tree)
+      if ptree = treemap[tree]
+        tree_path(treemap, ptree) + '/' + tree.name
+      else
+        ''
+      end
+    end
+
+    # Compare the canonicalized versions of the two names.
+    #
+    # name     - The human or canonical String page name.
+    # filename - the String filename on disk (including extension).
+    #
+    # Returns a Boolean.
+    def page_match(name, filename)
+      if match = self.class.valid_filename?(filename)
+        Page.cname(name).downcase == Page.cname(match).downcase
+      else
+        false
+      end
+    end
+  end
+end