gollum 2.4.11 → 2.4.12

data/lib/gollum/git_access.rb

@@ -1,249 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-module Gollum
-  # Controls all access to the Git objects from Gollum.  Extend this class to
-  # add custom caching for special cases.
-  class GitAccess
-    # Initializes the GitAccess instance.
-    #
-    # path          - The String path to the Git repository that holds the
-    #                 Gollum site.
-    # page_file_dir - String the directory in which all page files reside
-    #
-    # Returns this instance.
-    def initialize(path, page_file_dir = nil, bare = false)
-      @page_file_dir = page_file_dir
-      @path = path
-      @repo = Grit::Repo.new(path, { :is_bare => bare })
-      clear
-    end
-
-    # Public: Determines whether the Git repository exists on disk.
-    #
-    # Returns true if it exists, or false.
-    def exist?
-      @repo.git.exist?
-    end
-
-    # Public: Converts a given Git reference to a SHA, using the cache if
-    # available.
-    #
-    # ref - a String Git reference (ex: "master")
-    #
-    # Returns a String, or nil if the ref isn't found.
-    def ref_to_sha(ref)
-      ref = ref.to_s
-      return if ref.empty?
-      sha =
-        if sha?(ref)
-          ref
-        else
-          get_cache(:ref, ref) { ref_to_sha!(ref) }
-        end.to_s
-      sha.empty? ? nil : sha
-    end
-
-    # Public: Gets a recursive list of Git blobs for the whole tree at the
-    # given commit.
-    #
-    # ref - A String Git reference or Git SHA to a commit.
-    #
-    # Returns an Array of BlobEntry instances.
-    def tree(ref)
-      if sha = ref_to_sha(ref)
-        get_cache(:tree, sha) { tree!(sha) }
-      else
-        []
-      end
-    end
-
-    # Public: Fetches the contents of the Git blob at the given SHA.
-    #
-    # sha - A String Git SHA.
-    #
-    # Returns the String content of the blob.
-    def blob(sha)
-      cat_file!(sha)
-    end
-
-    # Public: Looks up the Git commit using the given Git SHA or ref.
-    #
-    # ref - A String Git SHA or ref.
-    #
-    # Returns a Grit::Commit.
-    def commit(ref)
-      if sha?(ref)
-        get_cache(:commit, ref) { commit!(ref) }
-      else
-        if sha = get_cache(:ref, ref)
-          commit(sha)
-        else
-          if cm = commit!(ref)
-            set_cache(:ref,    ref,   cm.id)
-            set_cache(:commit, cm.id, cm)
-          end
-        end
-      end
-    end
-
-    # Public: Clears all of the cached data that this GitAccess is tracking.
-    #
-    # Returns nothing.
-    def clear
-      @ref_map    = {}
-      @tree_map   = {}
-      @commit_map = {}
-    end
-
-    # Public: Refreshes just the cached Git reference data.  This should
-    # be called after every Gollum update.
-    #
-    # Returns nothing.
-    def refresh
-      @ref_map.clear
-    end
-
-    #########################################################################
-    #
-    # Internal Methods
-    #
-    #########################################################################
-
-    # Gets the String path to the Git repository.
-    attr_reader :path
-
-    # Gets the Grit::Repo instance for the Git repository.
-    attr_reader :repo
-
-    # Gets a Hash cache of refs to commit SHAs.
-    #
-    #   {"master" => "abc123", ...}
-    #
-    attr_reader :ref_map
-
-    # Gets a Hash cache of commit SHAs to a recursive tree of blobs.
-    #
-    #   {"abc123" => [<BlobEntry>, <BlobEntry>]}
-    #
-    attr_reader :tree_map
-
-    # Gets a Hash cache of commit SHAs to the Grit::Commit instance.
-    #
-    #     {"abcd123" => <Grit::Commit>}
-    #
-    attr_reader :commit_map
-
-    # Checks to see if the given String is a 40 character hex SHA.
-    #
-    # str - Possible String SHA.
-    #
-    # Returns true if the String is a SHA, or false.
-    def sha?(str)
-      !!(str =~ /^[0-9a-f]{40}$/)
-    end
-
-    # Looks up the Git SHA for the given Git ref.
-    #
-    # ref - String Git ref.
-    #
-    # Returns a String SHA.
-    def ref_to_sha!(ref)
-      @repo.git.rev_list({:max_count=>1}, ref)
-    rescue Grit::GitRuby::Repository::NoSuchShaFound
-    end
-
-    # Looks up the Git blobs for a given commit.
-    #
-    # sha - String commit SHA.
-    #
-    # Returns an Array of BlobEntry instances.
-    def tree!(sha)
-      tree  = @repo.git.native(:ls_tree,
-        {:r => true, :l => true, :z => true}, sha)
-      if tree.respond_to?(:force_encoding)
-        tree.force_encoding("UTF-8")
-      end
-      items = tree.split("\0").inject([]) do |memo, line|
-        memo << parse_tree_line(line)
-      end
-
-      if dir = @page_file_dir
-        regex = /^#{dir}\//
-        items.select { |i| i.path =~ regex }
-      else
-        items
-      end
-    end
-
-    # Reads the content from the Git db at the given SHA.
-    #
-    # sha - The String SHA.
-    #
-    # Returns the String content of the Git object.
-    def cat_file!(sha)
-      @repo.git.cat_file({:p => true}, sha)
-    end
-
-    # Reads a Git commit.
-    #
-    # sha - The string SHA of the Git commit.
-    #
-    # Returns a Grit::Commit.
-    def commit!(sha)
-      @repo.commit(sha)
-    end
-
-    # Attempts to get the given data from a cache.  If it doesn't exist, it'll
-    # pass the results of the yielded block to the cache for future accesses.
-    #
-    # name - The cache prefix used in building the full cache key.
-    # key  - The unique cache key suffix, usually a String Git SHA.
-    #
-    # Yields a block to pass to the cache.
-    # Returns the cached result.
-    def get_cache(name, key)
-      cache = instance_variable_get("@#{name}_map")
-      value = cache[key]
-      if value.nil? && block_given?
-        set_cache(name, key, value = yield)
-      end
-      value == :_nil ? nil : value
-    end
-
-    # Writes some data to the internal cache.
-    #
-    # name  - The cache prefix used in building the full cache key.
-    # key   - The unique cache key suffix, usually a String Git SHA.
-    # value - The value to write to the cache.
-    #
-    # Returns nothing.
-    def set_cache(name, key, value)
-      cache      = instance_variable_get("@#{name}_map")
-      cache[key] = value || :_nil
-    end
-
-    # Parses a line of output from the `ls-tree` command.
-    #
-    # line - A String line of output:
-    #          "100644 blob 839c2291b30495b9a882c17d08254d3c90d8fb53  Home.md"
-    #
-    # Returns an Array of BlobEntry instances.
-    def parse_tree_line(line)
-      mode, type, sha, size, *name = line.split(/\s+/)
-      BlobEntry.new(sha, name.join(' '), size.to_i)
-    end
-
-    # Decode octal sequences (\NNN) in tree path names.
-    #
-    # path - String path name.
-    #
-    # Returns a decoded String.
-    def decode_git_path(path)
-      if path[0] == ?" && path[-1] == ?"
-        path = path[1...-1]
-        path.gsub!(/\\\d{3}/)   { |m| m[1..-1].to_i(8).chr }
-      end
-      path.gsub!(/\\[rn"\\]/) { |m| eval(%("#{m.to_s}")) }
-      path
-    end
-  end
-end

data/lib/gollum/gitcode.rb

@@ -1,48 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require 'net/http'
-require 'net/https' # ruby 1.8.7 fix, remove at upgrade
-require 'uri'
-require 'open-uri'
-
-module Gollum
-  class Gitcode
-    def initialize path
-      raise(ArgumentError, 'path is nil or empty') if path.nil? or path.empty?
-
-      @uri = URI::HTTP.build({ 
-        :path   => self.unchomp(path), 
-        :host   => 'raw.github.com', 
-        :scheme => 'https',
-        :port   => 443 })
-    end
-
-    def contents
-      @contents ||= self.req @uri
-    end
-
-    def unchomp p
-      return p if p.nil?
-      p[0] == '/' ? p : ('/' + p)
-    end
-
-    def req uri, cut = 1
-      return "Too many redirects or retries" if cut >= 10
-      http = Net::HTTP.new uri.host, uri.port
-      http.use_ssl = true
-      resp = http.get uri.path, {
-        'Accept'        => 'text/plain',
-        'Cache-Control' => 'no-cache',
-        'Connection'    => 'keep-alive',
-        'Host'          => uri.host,
-        'User-Agent'    => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0'
-      }
-      code = resp.code.to_i
-      return resp.body if code == 200
-      return "Not Found" if code == 404
-      return "Unhandled Response Code #{code}" unless code == 304 or not resp.header['location'].nil?
-      loc = URI.parse resp.header['location']
-      uri2 = loc.relative?() ? (uri + loc) : loc # overloads (+)
-      return req uri2, (cut + 1)
-    end
-  end
-end

data/lib/gollum/markup.rb

@@ -1,664 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require 'digest/sha1'
-require 'cgi'
-require 'pygments'
-require 'base64'
-
-require File.expand_path '../frontend/helpers', __FILE__
-require File.expand_path '../gitcode', __FILE__
-
-# initialize Pygments
-Pygments.start
-
-module Gollum
-
-  class Markup
-    include Precious::Helpers
-
-    attr_accessor :toc
-    attr_reader   :metadata
-
-    # 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.text_data
-      @version = page.version.id if page.version
-      @format  = page.format
-      @sub_page = page.sub_page
-      @parent_page = page.parent_page
-      @dir     = ::File.dirname(page.path)
-      @tagmap  = {}
-      @codemap = {}
-      @wsdmap  = {}
-      @premap  = {}
-      @toc = nil
-      @metadata = nil
-      @to_xml = { :save_with => Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML ^ 1, :indent => 0, :encoding => 'UTF-8' }
-    end
-
-    # Render the content with Gollum wiki syntax on top of the file's own
-    # markup language.
-    #
-    # no_follow - Boolean that determines if rel="nofollow" is added to all
-    #             <a> tags.
-    # encoding  - Encoding Constant or String.
-    #
-    # Returns the formatted String content.
-    def render(no_follow = false, encoding = nil)
-      sanitize = no_follow ?
-        @wiki.history_sanitizer :
-        @wiki.sanitizer
-
-      data = @data.dup
-      data = extract_metadata(data)
-      data = extract_gitcode(data)
-      data = extract_code(data)
-      data = extract_wsd(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_tags(data)
-      data = process_code(data, encoding)
-
-      doc = Nokogiri::HTML::DocumentFragment.parse(data)
-      doc = sanitize.clean_node!(doc) if sanitize
-      doc,toc = process_headers(doc)
-      @toc = @sub_page ? ( @parent_page ? @parent_page.toc_data : "[[_TOC_]]" ) : toc
-      yield doc if block_given?
-      # nokogiri's save options are ored together. FORMAT has a value of 1 so ^ 1 removes it.
-      # formatting will create extra spaces in pre tags.
-      # https://github.com/sparklemotion/nokogiri/issues/782
-      # DEFAULT_HTML encodes unicode so XHTML is used for proper unicode support in href.
-      data = doc.to_xml( @to_xml )
-
-      data = process_toc_tags(data)
-      data = process_wsd(data)
-      data.gsub!(/<p><\/p>/) do
-        ''
-      end
-
-      data
-    end
-
-    # Inserts header anchors and creates TOC
-    #
-    # doc - Nokogiri parsed document
-    #
-    # Returns doc Document and toc String
-    def process_headers(doc)
-      toc = nil
-      doc.css('h1,h2,h3,h4,h5,h6').each do |h|
-        # must escape "
-        h_name = h.content.gsub(' ','-').gsub('"','%22')
-
-        level = h.name.gsub(/[hH]/,'').to_i
-
-        # Add anchors
-        h.add_child(%Q{<a class="anchor" id="#{h_name}" href="##{h_name}"></a>})
-
-        # Build TOC
-        toc ||= Nokogiri::XML::DocumentFragment.parse('<div class="toc"><div class="toc-title">Table of Contents</div></div>')
-        tail ||= toc.child
-        tail_level ||= 0
-
-        while tail_level < level
-          node = Nokogiri::XML::Node.new('ul', doc)
-          tail = tail.add_child(node)
-          tail_level += 1
-        end          
-        while tail_level > level
-          tail = tail.parent
-          tail_level -= 1
-        end
-        node = Nokogiri::XML::Node.new('li', doc)
-        # % -> %25 so anchors work on Firefox. See issue #475
-        node.add_child(%Q{<a href="##{h_name}">#{h.content}</a>})
-        tail.add_child(node)
-      end
-      toc = toc.to_xml(@to_xml) if toc != nil
-      [doc, toc]
-    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)
-      if @format == :asciidoc
-        return data
-      end
-      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).
-    #
-    # Returns the marked up String data.
-    def process_tags(data)
-      @tagmap.each do |id, tag|
-        # If it's preformatted, just put the tag back
-        if is_preformatted?(data, id)
-          data.gsub!(id) do
-            "[[#{tag}]]"
-          end
-        else
-          data.gsub!(id) do
-            process_tag(tag).gsub('%2F', '/')
-          end
-        end
-      end
-      data
-    end
-
-    # Find `id` within `data` and determine if it's within
-    # preformatted tags.
-    #
-    # data      - The String data (with placeholders).
-    # id        - The String SHA1 hash.
-    PREFORMATTED_TAGS = %w(code tt)
-    def is_preformatted?(data, id)
-      doc = Nokogiri::HTML::DocumentFragment.parse(data)
-      node = doc.search("[text()*='#{id}']").first
-      node && (PREFORMATTED_TAGS.include?(node.name) ||
-        node.ancestors.any? { |a| PREFORMATTED_TAGS.include?(a.name) })
-    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 tag =~ /^_TOC_$/
-        %{[[#{tag}]]}
-      elsif html = process_image_tag(tag)
-        html
-      elsif html = process_file_link_tag(tag)
-        html
-      else
-        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('|')
-      return if parts.size.zero?
-
-      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)$/i
-        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 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('|')
-      return if parts.size.zero?
-
-      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('|')
-      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 = @wiki.page_class.cname(page.name)
-          presence  = "present"
-        end
-        link = ::File.join(@wiki.base_path, page ? page.escaped_url_path : CGI.escape(link_name))
-
-        # //page is invalid
-        # strip all duplicate forward slashes using helpers.rb trim_leading_slash
-        # //page => /page
-        link = trim_leading_slash link
-
-        %{<a class="internal #{presence}" href="#{link}#{extra}">#{name}</a>}
-      end
-    end
-
-
-    # Process the special table of contents tag [[_TOC_]]
-    #
-    # data      - The String data (with placeholders).
-    #
-    # Returns the marked up String data.
-    def process_toc_tags(data)
-      data.gsub!("[[_TOC_]]") do
-        @toc.nil? ? '' : @toc
-      end
-      data
-    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, version=@version)
-      if name =~ /^\//
-        @wiki.file(name[1..-1], version)
-      else
-        path = @dir == '.' ? name : ::File.join(@dir, name)
-        @wiki.file(path, version)
-      end
-    end
-
-    # Find a page from a given cname.  If the page has an anchor (#) and has
-    # no match, strip the anchor and try again.
-    #
-    # cname - The String canonical page name including path.
-    #
-    # 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)
-      slash = cname.rindex('/')
-
-      unless slash.nil?
-        name = cname[slash+1..-1]
-        path = cname[0..slash]
-        page = @wiki.paged(name, path)
-      else
-        page = @wiki.paged(cname, '/') || @wiki.page(cname)
-      end
-
-      if page
-        return page
-      end
-      if pos = cname.index('#')
-        [@wiki.page(cname[0...pos]), cname[pos..-1]]
-      end
-    end
-
-    #########################################################################
-    #
-    # Gitcode - fetch code from github search path and replace the contents
-    #           to a code-block that gets run the next parse.
-    #           Acceptable formats:
-    #              ```language:local-file.ext```
-    #              ```language:/abs/other-file.ext```
-    #              ```language:github/gollum/master/somefile.txt```
-    #
-    #########################################################################
-
-    def extract_gitcode data
-      data.gsub /^[ \t]*``` ?([^:\n\r]+):([^`\n\r]+)```/ do
-        contents = ''
-        # Use empty string if $2 is nil.
-        uri = $2 || ''
-        # Detect local file.
-        if uri[0..6] != 'github/'
-            if file = self.find_file(uri, @wiki.ref)
-              contents = file.raw_data
-            else
-              # How do we communicate a render error?
-              next "File not found: #{Rack::Utils::escape_html(uri)}"
-            end
-        else
-          contents = Gollum::Gitcode.new(uri).contents
-        end
-
-        "```#{$1}\n#{contents}\n```\n"
-      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!(/^([ \t]*)(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n\1(~~~+)[ \t\r]*$/m) do
-        m_indent = $1
-        m_start  = $2 # ~~~
-        m_lang   = $3
-        m_code   = $4
-        m_end    = $5 # ~~~
-
-        # start and finish tilde fence must be the same length
-        return '' if m_start.length != m_end.length
-
-        lang   = m_lang ? m_lang.strip : nil
-        id     = Digest::SHA1.hexdigest("#{lang}.#{m_code}")
-        cached = check_cache(:code, id)
-
-        # extract lang from { .ruby } or { #stuff .ruby .indent }
-        # see http://johnmacfarlane.net/pandoc/README.html#delimited-code-blocks
-
-        if lang
-            lang = lang.match(/\.([^}\s]+)/)
-            lang = lang[1] unless lang.nil?
-        end
-
-        @codemap[id] = cached   ?
-          { :output => cached } :
-          { :lang => lang, :code => m_code, :indent => m_indent }
-
-        "#{m_indent}#{id}" # print the SHA1 ID with the proper indentation
-      end
-
-      data.gsub!(/^([ \t]*)``` ?([^\r\n]+)?\r?\n(.+?)\r?\n\1```[ \t]*\r?$/m) do
-        lang   = $2 ? $2.strip : nil
-        id     = Digest::SHA1.hexdigest("#{lang}.#{$3}")
-        cached = check_cache(:code, id)
-        @codemap[id] = cached   ?
-          { :output => cached } :
-          { :lang => lang, :code => $3, :indent => $1 }
-        "#{$1}#{id}" # print the SHA1 ID with the proper indentation
-      end
-      data
-    end
-
-    # Remove the leading space from a code block. Leading space
-    # is only removed if every single line in the block has leading
-    # whitespace.
-    #
-    # code      - The code block to remove spaces from
-    # regex     - A regex to match whitespace
-    def remove_leading_space(code, regex)
-      if code.lines.all? { |line| line =~ /\A\r?\n\Z/ || line =~ regex }
-        code.gsub!(regex) do
-          ''
-        end
-      end
-    end
-
-    # Process all code from the codemap and replace the placeholders with the
-    # final HTML.
-    #
-    # data     - The String data (with placeholders).
-    # encoding - Encoding Constant or String.
-    #
-    # Returns the marked up String data.
-    def process_code(data, encoding = nil)
-      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]
-
-        remove_leading_space(code, /^#{spec[:indent]}/m)
-        remove_leading_space(code, /^(  |\t)/m)
-
-        blocks << [spec[:lang], code]
-      end
-
-      highlighted = []
-      blocks.each do |lang, code|
-        encoding ||= 'utf-8'
-        begin
-          # must set startinline to true for php to be highlighted without <?
-          # http://pygments.org/docs/lexers/
-          hl_code = Pygments.highlight(code, :lexer => lang, :options => {:encoding => encoding.to_s, :startinline => true})
-        rescue
-          hl_code = code
-        end
-        highlighted << hl_code
-      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) do
-          body
-        end
-      end
-
-      data
-    end
-
-    #########################################################################
-    #
-    # Sequence Diagrams
-    #
-    #########################################################################
-
-    # Extract all sequence diagram blocks into the wsdmap and replace with
-    # placeholders.
-    #
-    # data - The raw String data.
-    #
-    # Returns the placeholder'd String data.
-    def extract_wsd(data)
-      data.gsub(/^\{\{\{\{\{\{ ?(.+?)\r?\n(.+?)\r?\n\}\}\}\}\}\}\r?$/m) do
-        id = Digest::SHA1.hexdigest($2)
-        @wsdmap[id] = { :style => $1, :code => $2 }
-        id
-      end
-    end
-
-    # Process all diagrams from the wsdmap and replace the placeholders with
-    # the final HTML.
-    #
-    # data - The String data (with placeholders).
-    #
-    # Returns the marked up String data.
-    def process_wsd(data)
-      @wsdmap.each do |id, spec|
-        style = spec[:style]
-        code = spec[:code]
-        data.gsub!(id) do
-          Gollum::WebSequenceDiagram.new(code, style).to_tag
-        end
-      end
-      data
-    end
-
-    #########################################################################
-    #
-    # Metadata
-    #
-    #########################################################################
-
-    # Extract metadata for data and build metadata table. Metadata
-    # is content found between markers, and must
-    # be a valid YAML mapping.
-    #
-    # Because ri and ruby 1.8.7 are awesome, the markers can't
-    # be included in this documentation without triggering
-    # `Unhandled special: Special: type=17`
-    # Please read the source code for the exact markers
-    #
-    # Returns the String of formatted data with metadata removed.
-    def extract_metadata(data)
-      @metadata = {}
-      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
-
-  MarkupGFM = Markup
-end