gollum-lib 1.0.9 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12c5ce0dd57482d2d3264712ac15839e67e6398d
-  data.tar.gz: 3b0b498880df3a86d6fb8a3d09acab8ed629043c
+  metadata.gz: 2e62158d0795431631a6a845ac26a221535c8604
+  data.tar.gz: 35c5ad577b84b262fd492dfc2e5b30f92d5f97ee
 SHA512:
-  metadata.gz: 3d8a845aadfde384b2322851058937d9eb0724d9098b072f604eec6f41054eb3faf86b7430604caa99fd7ea2298db3f8c94b03a53215603fd435eccba956af4a
-  data.tar.gz: 25974065b8c080aa366aa345891aa51475d43aa424e73f5c08c57a807fcbaeccd07d7d2bdfcb530d682c321d6ce98b23eb5275c4746cef37aed0d293bf2a7fda
+  metadata.gz: 54dd123e3f0cc5c2dc7df860a289d1ca3a46edd360c4d8ecf0dabf3e9d6ee3b2e68383c4b21b3d87f82e1309df3cfd24515e07e7b219a518557e1043ea2dbaa2
+  data.tar.gz: 5bd2a239672e66b8a0364acdee7806e1be851b821dfb5b471328d8ffeb8e8581bfea27ee5641363138898e4a6c51530fd5c0a948277190cfe779f11f558716af

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'rake', '~> 10.0.3'

data/README.md

@@ -20,7 +20,7 @@ Gollum-lib follows the rules of [Semantic Versioning](http://semver.org/) and us
 ## SYSTEM REQUIREMENTS
 
 - Python 2.5+ (2.7.3 recommended)
-- Ruby 1.8.7+ (1.9.3 recommended)
+- Ruby 1.9.3+ (1.9.3 recommended)
 - Unix like operating system (OS X, Ubuntu, Debian, and more)
 - Will not work on Windows (because of [grit](https://github.com/github/grit))
 

data/gollum-lib.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.9"
 
   s.name              = 'gollum-lib'
-  s.version           = '1.0.9'
-  s.date              = '2013-11-02'
+  s.version           = '2.0.0'
+  s.date              = '2014-02-20'
   s.rubyforge_project = 'gollum-lib'
   s.license           = 'MIT'
 
@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency('gitlab-grit', '2.6.0')
   s.add_dependency('github-markup', ['>= 0.7.5', '< 1.0.0'])
-  s.add_dependency('pygments.rb', '~> 0.5.2')
+  s.add_dependency('rouge', '~> 1.3.1')
   s.add_dependency('sanitize', '~> 2.0.6')
   s.add_dependency('nokogiri', '~> 1.6.0')
   s.add_dependency('stringex', '~> 2.1.0')
@@ -62,6 +62,16 @@ Gem::Specification.new do |s|
     lib/gollum-lib/committer.rb
     lib/gollum-lib/file.rb
     lib/gollum-lib/file_view.rb
+    lib/gollum-lib/filter.rb
+    lib/gollum-lib/filter/code.rb
+    lib/gollum-lib/filter/metadata.rb
+    lib/gollum-lib/filter/plain_text.rb
+    lib/gollum-lib/filter/remote_code.rb
+    lib/gollum-lib/filter/render.rb
+    lib/gollum-lib/filter/sanitize.rb
+    lib/gollum-lib/filter/tags.rb
+    lib/gollum-lib/filter/toc.rb
+    lib/gollum-lib/filter/wsd.rb
     lib/gollum-lib/git_access.rb
     lib/gollum-lib/gitcode.rb
     lib/gollum-lib/grit_ext.rb
@@ -71,9 +81,7 @@ Gem::Specification.new do |s|
     lib/gollum-lib/markups.rb
     lib/gollum-lib/page.rb
     lib/gollum-lib/pagination.rb
-    lib/gollum-lib/remote_code.rb
     lib/gollum-lib/sanitization.rb
-    lib/gollum-lib/web_sequence_diagram.rb
     lib/gollum-lib/wiki.rb
     licenses/licenses.txt
   ]

data/lib/gollum-lib.rb

@@ -23,7 +23,7 @@ require File.expand_path('../gollum-lib/file_view', __FILE__)
 require File.expand_path('../gollum-lib/markup', __FILE__)
 require File.expand_path('../gollum-lib/markups', __FILE__)
 require File.expand_path('../gollum-lib/sanitization', __FILE__)
-require File.expand_path('../gollum-lib/web_sequence_diagram', __FILE__)
+require File.expand_path('../gollum-lib/filter', __FILE__)
 
 # Set ruby to UTF-8 mode
 # This is required for Ruby 1.8.7 which gollum still supports.
@@ -31,7 +31,7 @@ $KCODE = 'U' if RUBY_VERSION[0,3] == '1.8'
 
 module Gollum
   module Lib
-    VERSION = '1.0.9'
+    VERSION = '2.0.0'
   end
 
   def self.assets_path

data/lib/gollum-lib/filter.rb

@@ -0,0 +1,78 @@
+# A "filter", in Gollum-speak, is an object which extracts tokens from an
+# input stream of an arbitrary markup language, then replaces them with a
+# final form in a rendered form of the same document.  Filters are composed
+# into a "filter chain", which forms the order in which filters are applied
+# in both the extraction and processing phases (processing happens in the
+# reverse order to extraction).  A single instance of a filter class is used
+# for both the extraction and processing, so you can store internal state
+# from the extraction phase for use in the processing phase.
+#
+# Any class which is to be used as a filter must have an `initialize` method
+# which takes a single mandatory argument (the instance of the `Markup`
+# class we're being called from), and must implement two methods: `extract`
+# and `process`, both of which must take a string as input and return a
+# (possibly modified) form of that string as output.
+#
+# An example rendering session: consider a filter chain with three filters
+# in it, :A, :B, and :C (filter chains are specified as symbols, which are
+# taken to be class names within the Gollum::Filter namespace).  An
+# equivalent of the following will take place:
+#
+#     a = Gollum::Filter.const_get(:A).new
+#     b = Gollum::Filter.const_get(:B).new
+#     c = Gollum::Filter.const_get(:C).new
+#
+#     data = "<some markup>"
+#
+#     data = a.extract(data)
+#     data = b.extract(data)
+#     data = c.extract(data)
+#
+#     data = c.process(data)
+#     data = b.process(data)
+#     data = a.process(data)
+#
+#     # `data` now contains the rendered document, ready for processing
+#
+# Note how the extraction steps go in the order of the filter chain, while
+# the processing steps go in the reverse order.  There hasn't (yet) been a
+# case where that is a huge problem.
+#
+# If your particular filter doesn't need to do something with either the
+# original markup or rendered forms, you can simply define the relevant
+# method to be a pass-through (`def extract(d) d; end`), but you *must*
+# define both methods yourself.
+#     
+module Gollum
+  class Filter
+    include Gollum::Helpers
+    
+    # Setup the object.  Sets `@markup` to be the instance of Gollum::Markup that
+    # is running this filter chain, and sets `@map` to be an empty hash (for use
+    # in your extract/process operations).
+    def initialize(markup)
+      @markup = markup
+      @map    = {}
+    end
+    
+    def extract(_d)
+      raise RuntimeError,
+            "#{self.class} has not implemented ##extract!"
+    end
+
+    def process(_d)
+      raise RuntimeError,
+            "#{self.class} has not implemented ##process!"
+    end
+    
+    protected
+    # Render a (presumably) non-fatal error as HTML
+    #
+    def html_error(message)
+      "<p class=\"gollum-error\">#{message}</p>"
+    end
+  end
+end
+
+# Load all standard filters
+Dir[File.expand_path('../filter/*.rb', __FILE__)].each { |f| require f }

data/lib/gollum-lib/filter/code.rb

@@ -0,0 +1,123 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Code
+#
+# Render a block of code using the Rouge syntax-highlighter.
+class Gollum::Filter::Code < Gollum::Filter
+  def extract(data)
+    return data if @markup.format == :txt
+    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
+      next '' if m_start.length != m_end.length
+
+      lang   = m_lang ? m_lang.strip : nil
+      id     = Digest::SHA1.hexdigest("#{lang}.#{m_code}")
+      cached = @markup.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
+
+      @map[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 = @markup.check_cache(:code, id)
+      @map[id] = cached   ?
+        { :output => cached } :
+        { :lang => lang, :code => $3, :indent => $1 }
+      "#{$1}#{id}" # print the SHA1 ID with the proper indentation
+    end
+
+    data
+  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(data)
+    return data if data.nil? || data.size.zero? || @map.size.zero?
+
+    blocks = []
+
+    @map.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 = @markup.encoding || 'utf-8'
+      begin
+        if Rouge::Lexer.find(lang).nil?
+          lexer = Rouge::Lexers::PlainText.new
+          formatter = Rouge::Formatters::HTML.new(:wrap => false)
+          hl_code = formatter.format(lexer.lex(code))
+          hl_code = "<pre class='highlight'><span class='err'>#{CGI.escapeHTML(hl_code)}</span></pre>"
+        else
+          hl_code = Rouge.highlight(code, lang, 'html')  
+        end
+      rescue
+        hl_code = code
+      end
+      highlighted << hl_code
+    end
+
+    @map.each do |id, spec|
+      body = spec[:output] || begin
+        if (body = highlighted.shift.to_s).size > 0
+          @markup.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
+
+  private
+  # 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
+end

data/lib/gollum-lib/filter/metadata.rb

@@ -0,0 +1,27 @@
+# Extract metadata for data and build metadata table.  Metadata consists of
+# key/value pairs in "key:value" format found between markers.  Each
+# key/value pair must be on its own line.  Internal whitespace in keys and
+# values is preserved, but external whitespace is ignored.
+#
+# 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
+class Gollum::Filter::Metadata < Gollum::Filter
+  def extract(data)
+    # The markers are `<!-- ---` and `-->`
+    data.gsub(/\<\!--+\s+---(.*?)--+\>/m) do
+      @markup.metadata ||= {}
+      # Split untrusted input on newlines, then remove bits that look like
+      # HTML elements before parsing each line.
+      $1.split("\n").each do |line|
+        line.gsub!(/<[^>]*>/, '')
+        k, v = line.split(':', 2)
+        @markup.metadata[k.strip] = (v ? v.strip : '') if k
+      end
+      ''
+    end
+  end
+  
+  def process(d) d; end
+end

data/lib/gollum-lib/filter/plain_text.rb

@@ -0,0 +1,15 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Plain Text
+#
+# Render plain text documents in a <pre> block without any special markup.
+
+class Gollum::Filter::PlainText < Gollum::Filter
+
+  def extract(data)
+    @markup.format == :txt ? "<pre>#{CGI.escapeHTML(data)}</pre>" : data
+  end
+
+  def process(data); data ; end
+
+end

data/lib/gollum-lib/filter/remote_code.rb

@@ -0,0 +1,61 @@
+# ~*~ encoding: utf-8 ~*~
+require 'net/http'
+require 'net/https' # ruby 1.8.7 fix, remove at upgrade
+require 'uri'
+require 'open-uri'
+
+# Remote code - fetch code from url 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:https://example.com/somefile.txt```
+#
+class Gollum::Filter::RemoteCode < Gollum::Filter
+  def extract(data)
+    return data if @markup.format == :txt
+    data.gsub /^[ \t]*``` ?([^:\n\r]+):((http)?[^`\n\r]+)```/ do
+      language = $1
+      uri = $2
+      protocol = $3
+
+      # Detect local file
+      if protocol.nil?
+        if file = @markup.find_file(uri, @markup.wiki.ref)
+          contents = file.raw_data
+        else
+          # How do we communicate a render error?
+          next html_error("File not found: #{CGI::escapeHTML(uri)}")
+        end
+      else
+        contents = req(uri)
+      end
+
+      "```#{language}\n#{contents}\n```\n"
+    end
+  end
+  
+  def process(d) d; end
+
+  private
+
+    def req uri, cut = 1
+      uri = URI(uri)
+      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',
+        '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 (+)
+      req uri2, (cut + 1)
+    end
+end

data/lib/gollum-lib/filter/render.rb

@@ -0,0 +1,18 @@
+# ~*~ encoding: utf-8 ~*~
+
+class Gollum::Filter::Render < Gollum::Filter
+  def extract(data)
+    begin
+      data = GitHub::Markup.render(@markup.name, data)
+      if data.nil?
+        raise "There was an error converting #{@markup.name} to HTML."
+      end
+    rescue Object => e
+      data = html_error("Failed to render page: #{e.message}")
+    end
+
+    data
+  end
+
+  def process(d) d; end
+end

data/lib/gollum-lib/filter/sanitize.rb

@@ -0,0 +1,16 @@
+# ~*~ encoding: utf-8 ~*~
+
+class Gollum::Filter::Sanitize < Gollum::Filter
+  def extract(d) d; end
+  
+  def process(data)
+    if @markup.sanitize
+      doc = Nokogiri::HTML::DocumentFragment.parse(data)
+      doc = @markup.sanitize.clean_node!(doc)
+
+      doc.to_xml(@markup.to_xml_opts)
+    else
+      data
+    end
+  end
+end

data/lib/gollum-lib/filter/tags.rb

@@ -0,0 +1,292 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Render all tags (things in double-square-brackets).  This one's a biggie.
+class Gollum::Filter::Tags < Gollum::Filter
+  # Extract all tags into the tagmap and replace with placeholders.
+  def extract(data)
+    return data if @markup.format == :txt || @markup.format == :asciidoc
+    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)
+          @map[id] = link
+          "#{pre}#{id}#{post}"
+        else
+          $&
+        end
+      else
+        id = Digest::SHA1.hexdigest($2)
+        @map[id] = $2
+        "#{$1}#{id}#{$3}"
+      end
+    end
+    data
+  end
+
+  # Process all tags from the tagmap and replace the placeholders with the
+  # final markup.
+  def process(data)
+    @map.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
+
+  private
+  # 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 tag =~ /^_$/
+      %{<div class="clearfloats"></div>}
+    elsif html = process_include_tag(tag)
+      html
+    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 include 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_include_tag(tag)
+    return unless /^include:/.match(tag)
+    page_name = tag[8..-1]
+    resolved_page_name =  ::File.expand_path(page_name, "/"+@markup.dir)
+
+    if @markup.include_levels > 0
+      page = find_page_from_name(resolved_page_name)
+      if page
+        page.formatted_data(@markup.encoding, @markup.include_levels-1)
+      else
+        html_error("Cannot include #{process_page_link_tag(resolved_page_name)} - does not exist yet")
+      end
+    else
+      html_error("Too many levels of included pages, will not include #{process_page_link_tag(resolved_page_name)}")
+    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 = @markup.find_file(name)
+      ::File.join @markup.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 = @markup.find_file(path)
+      ::File.join @markup.wiki.base_path, file.path
+    elsif path =~ %r{^https?://}
+      path
+    else
+      nil
+    end
+
+    if name && path && file
+      %{<a href="#{::File.join @markup.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 @markup.format == :mediawiki
+
+    name, page_name = *parts.compact.map(&:strip)
+    cname = @markup.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 = @markup.wiki.page_class.cname(page.name)
+        presence  = "present"
+      end
+      link = ::File.join(@markup.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
+
+  # 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 = @markup.wiki.paged(name, path)
+    else
+      page = @markup.wiki.paged(cname, '/') || @markup.wiki.page(cname)
+    end
+
+    if page
+      return page
+    end
+    if pos = cname.index('#')
+      [@markup.wiki.page(cname[0...pos]), cname[pos..-1]]
+    end
+  end
+end