gollum 2.2.1 → 2.2.2

data/test/test_app_helpers.rb

@@ -1,13 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
-
-context "Precious::Helpers" do
-  include Precious::Helpers
-
-  test "extracting paths from URLs" do
-    assert_nil extract_path('Eye-Of-Sauron')
-    assert_equal 'Mordor', extract_path('Mordor/Sauron')
-    assert_equal 'Mordor/Sauron', extract_path('Mordor/Sauron/Evil')
-  end
-end
-

data/test/test_committer.rb

@@ -1,64 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
-
-context "Wiki" do
-  setup do
-    @wiki = Gollum::Wiki.new(testpath("examples/lotr.git"))
-  end
-
-  test "normalizes commit hash" do
-    commit = {:message => 'abc'}
-    name  = @wiki.repo.config['user.name']  || @wiki.default_committer_name
-    email = @wiki.repo.config['user.email'] ||  @wiki.default_committer_email
-    committer = Gollum::Committer.new(@wiki, commit)
-    assert_equal name,  committer.actor.name
-    assert_equal email, committer.actor.email
-
-    commit[:name]  = 'bob'
-    commit[:email] = ''
-    committer = Gollum::Committer.new(@wiki, commit)
-    assert_equal 'bob',  committer.actor.name
-    assert_equal email, committer.actor.email
-
-    commit[:email] = 'foo@bar.com'
-    committer = Gollum::Committer.new(@wiki, commit)
-    assert_equal 'bob',  committer.actor.name
-    assert_equal 'foo@bar.com', committer.actor.email
-  end
-
-  test "yield after_commit callback" do
-    @path = cloned_testpath('examples/lotr.git')
-    yielded = nil
-    begin
-      wiki = Gollum::Wiki.new(@path)
-      committer = Gollum::Committer.new(wiki)
-      committer.after_commit do |index, sha1|
-        yielded = sha1
-        assert_equal committer, index
-      end
-
-      res = wiki.write_page("Gollum", :markdown, "# Gollum",
-        :committer => committer)
-
-      assert_equal committer, res
-
-      sha1 = committer.commit
-      assert_equal sha1, yielded
-    ensure
-      FileUtils.rm_rf(@path)
-    end
-  end
-
-  test "parents with default master ref" do
-    ref = '629aa678272b017a4d136d35e77ac94d80b08dc2'
-    committer = Gollum::Committer.new(@wiki)
-    assert_equal ref,  committer.parents.first.sha
-  end
-
-  test "parents with custom ref" do
-    ref = '60f12f4254f58801b9ee7db7bca5fa8aeefaa56b'
-    @wiki = Gollum::Wiki.new(testpath("examples/lotr.git"), :ref => ref)
-    committer = Gollum::Committer.new(@wiki)
-    assert_equal ref,  committer.parents.first.sha
-  end
-end

data/test/test_file.rb

@@ -1,27 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-path = File.join(File.dirname(__FILE__), "helper")
-require File.expand_path(path)
-
-context "File" do
-  setup do
-    @wiki = Gollum::Wiki.new(testpath("examples/lotr.git"))
-  end
-
-  test "new file" do
-    file = Gollum::File.new(@wiki)
-    assert_nil file.raw_data
-  end
-
-  test "existing file" do
-    commit = @wiki.repo.commits.first
-    file   = @wiki.file("Mordor/todo.txt")
-    assert_equal "[ ] Write section on Ents\n", file.raw_data
-    assert_equal 'todo.txt',         file.name
-    assert_equal commit.id,          file.version.id
-    assert_equal commit.author.name, file.version.author.name
-  end
-
-  test "accessing tree" do
-    assert_nil @wiki.file("Mordor")
-  end
-end

data/test/test_file_view.rb

@@ -1,102 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require File.expand_path '../../lib/gollum/file_view', __FILE__
-
-class FakePage
-  def initialize filepath
-    @filepath = filepath  
-  end
-  
-  # From page.rb
-  def filename_stripped
-    ::File.basename(@filepath, ::File.extname(@filepath))
-  end
-
-  def path
-    return @filepath
-  end
-
-  # From page.rb
-  def name
-    self.class.canonicalize_filename @filepath
-  end
-
-  # From page.rb
-  def self.strip_filename filename
-    ::File.basename( filename, ::File.extname( filename ))
-  end
-
-  # From page.rb
-  def self.canonicalize_filename filename
-    strip_filename(filename).gsub('-', ' ')
-  end
-end
-
-class FakePages
-  def initialize filepath_array
-    @array = filepath_array.map { | filepath | FakePage.new filepath }
-  end
-
-  def size
-    @array.size
-  end
-  
-  def [] index
-    @array[ index ]
-  end
-end
-
-def view pages
-  Gollum::FileView.new( pages ).render_files
-end
-
-@@test_path = File.expand_path( '../file_view/' , __FILE__ ) + '/'
-
-def read file
-  File.read @@test_path + file + '.txt'
-end
-
-# For creating expected files.
-# write name, actual
-def write file, content
-  File.open(@@test_path + file + '.txt', 'w') do | f |
-    f.write content
-  end
-end
-
-def check name, pages_array
-  pages = FakePages.new pages_array
-  expected = read name
-  actual = view pages
-  assert_equal expected, actual
-end
-
-# Test Notes
-# root files must be before any folders.
-# Home.md => file at root folder
-# docs/sanitization.md => file within folder
-context 'file_view' do
-  test 'one file' do
-    check '1_file', [ '0.md' ]
-  end
-
-  test 'one folder' do
-    check '1_folder', [ 'folder0/' ]
-  end
-
-  test 'one file with one folder' do
-    check '1_file_1_folder', [ 'folder0/0.md' ]
-  end
-
-  test 'two files with two folders' do
-    check '2_files_2_folders', [ 'folder0/0.md', 'folder1/1.md' ]
-  end
-
-  test 'two files with two folders and one root file' do
-    check '2_files_2_folders_1_root', [ 'root.md', 'folder0/0.md', 'folder1/1.md' ]
-  end
-
-  test 'nested folders' do
-    check 'nested_folders', [ 'folder0/folder1/folder2/0.md', 'folder0/folder1/folder3/1.md', 'folder4/2.md' ]
-  end
-end # context

data/test/test_git_access.rb

@@ -1,53 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
-
-context "GitAccess" do
-  setup do
-    @access = Gollum::GitAccess.new(testpath("examples/lotr.git"))
-  end
-
-  test "#commit fills commit_map cache" do
-    assert @access.commit_map.empty?
-    actual   = @access.repo.commits.first
-    expected = @access.commit(actual.id)
-    assert_equal actual.message, expected.message
-    assert_equal actual.message, @access.commit_map[actual.id].message
-  end
-
-  test "#tree_map_for caches ref and tree" do
-    assert @access.ref_map.empty?
-    assert @access.tree_map.empty?
-    @access.tree 'master'
-    assert_equal({"master"=>"629aa678272b017a4d136d35e77ac94d80b08dc2"}, @access.ref_map)
-
-    @access.tree '1db89ebba7e2c14d93b94ff98cfa3708a4f0d4e3'
-    map = @access.tree_map['1db89ebba7e2c14d93b94ff98cfa3708a4f0d4e3']
-    assert_equal 'Bilbo-Baggins.md',        map[0].path
-    assert_equal '',                        map[0].dir
-    assert_equal map[0].path,               map[0].name
-    assert_equal 'Mordor/Eye-Of-Sauron.md', map[3].path
-    assert_equal '/Mordor',                 map[3].dir
-    assert_equal 'Eye-Of-Sauron.md',        map[3].name
-  end
-
-  test "#tree_map_for only caches tree for commit" do
-    assert @access.tree_map.empty?
-    @access.tree '60f12f4254f58801b9ee7db7bca5fa8aeefaa56b'
-    assert @access.ref_map.empty?
-
-    entry = @access.tree_map['60f12f4254f58801b9ee7db7bca5fa8aeefaa56b'][0]
-    assert_equal 'Bilbo-Baggins.md', entry.path
-  end
-
-  test "cannot access commit from invalid ref" do
-    assert_nil @access.commit('foo')
-  end
-
-  test "cannot access sha from invalid ref" do
-    assert_nil @access.ref_to_sha('foo')
-  end
-
-  test "cannot access tree from invalid ref" do
-    assert_equal [], @access.tree('foo')
-  end
-end

data/test/test_markup.rb

@@ -1,732 +0,0 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
-
-context "Markup" do
-  setup do
-    @path = testpath("examples/test.git")
-    FileUtils.rm_rf(@path)
-    Grit::Repo.init_bare(@path)
-    Gollum::Wiki.default_options = {:universal_toc => false}
-    @wiki = Gollum::Wiki.new(@path)
-  end
-
-  teardown do
-    FileUtils.rm_r(File.join(File.dirname(__FILE__), *%w[examples test.git]))
-  end
-
-  test "formats page from Wiki#pages" do
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[Foo]][[Bar]] b", commit_details)
-    assert @wiki.pages[0].formatted_data
-  end
-
-  # This test is to assume that Sanitize.clean doesn't raise Encoding::CompatibilityError on ruby 1.9
-  test "formats non ASCII-7 character page from Wiki#pages" do
-    wiki = Gollum::Wiki.new(testpath("examples/yubiwa.git"))
-    assert_nothing_raised(defined?(Encoding) && Encoding::CompatibilityError) do
-      assert wiki.page("strider").formatted_data
-    end
-  end
-
-  test "Gollum::Markup#render yields a DocumentFragment" do
-    yielded = false
-    @wiki.write_page("Yielded", :markdown, "abc", commit_details)
-
-    page   = @wiki.page("Yielded")
-    markup = Gollum::Markup.new(page)
-    markup.render do |doc|
-      assert_kind_of Nokogiri::HTML::DocumentFragment, doc
-      yielded = true
-    end
-    assert yielded
-  end
-
-  test "Gollum::Page#formatted_data yields a DocumentFragment" do
-    yielded = false
-    @wiki.write_page("Yielded", :markdown, "abc", commit_details)
-
-    page   = @wiki.page("Yielded")
-    page.formatted_data do |doc|
-      assert_kind_of Nokogiri::HTML::DocumentFragment, doc
-      yielded = true
-    end
-    assert yielded
-  end
-
-  #########################################################################
-  #
-  # Links
-  #
-  #########################################################################
-
-  test "double page links no space" do
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[Foo]][[Bar]] b", commit_details)
-
-    # "<p>a <a class=\"internal absent\" href=\"/Foo\">Foo</a><a class=\"internal absent\" href=\"/Bar\">Bar</a> b</p>"
-    page    = @wiki.page("Bilbo Baggins")
-    doc     = Nokogiri::HTML page.formatted_data
-    paras   = doc / :p
-    para    = paras.first
-    anchors = para / :a
-    assert_equal 1, paras.size
-    assert_equal 2, anchors.size
-    assert_equal 'internal absent', anchors[0]['class']
-    assert_equal 'internal absent', anchors[1]['class']
-    assert_equal '/Foo',            anchors[0]['href']
-    assert_equal '/Bar',            anchors[1]['href']
-    assert_equal 'Foo',             anchors[0].text
-    assert_equal 'Bar',             anchors[1].text
-  end
-
-  test "double page links with space" do
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[Foo]] [[Bar]] b", commit_details)
-
-    # "<p>a <a class=\"internal absent\" href=\"/Foo\">Foo</a> <a class=\"internal absent\" href=\"/Bar\">Bar</a> b</p>"
-    page = @wiki.page("Bilbo Baggins")
-    doc     = Nokogiri::HTML page.formatted_data
-    paras   = doc / :p
-    para    = paras.first
-    anchors = para / :a
-    assert_equal 1, paras.size
-    assert_equal 2, anchors.size
-    assert_equal 'internal absent', anchors[0]['class']
-    assert_equal 'internal absent', anchors[1]['class']
-    assert_equal '/Foo',            anchors[0]['href']
-    assert_equal '/Bar',            anchors[1]['href']
-    assert_equal 'Foo',             anchors[0].text
-    assert_equal 'Bar',             anchors[1].text
-  end
-
-  test "page link" do
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[Bilbo Baggins]] b", commit_details)
-
-    page = @wiki.page("Bilbo Baggins")
-    output = page.formatted_data
-    assert_match /class="internal present"/, output
-    assert_match /href="\/Bilbo-Baggins"/,   output
-    assert_match /\>Bilbo Baggins\</,        output
-  end
-
-  test "adds nofollow to links on historical pages" do
-    sha1 = @wiki.write_page("Sauron", :markdown, "a [[b]] c", commit_details)
-    page = @wiki.page("Sauron")
-    sha2 = @wiki.update_page(page, page.name, :markdown, "c [[b]] a", commit_details)
-    regx = /rel="nofollow"/
-    assert_no_match regx, page.formatted_data
-    assert_match    regx, @wiki.page(page.name, sha1).formatted_data
-    assert_match    regx, @wiki.page(page.name, sha2).formatted_data
-  end
-
-  test "absent page link" do
-    @wiki.write_page("Tolkien", :markdown, "a [[J. R. R. Tolkien]]'s b", commit_details)
-
-    page = @wiki.page("Tolkien")
-    output = page.formatted_data
-    assert_match /class="internal absent"/,         output
-    assert_match /href="\/J\.\-R\.\-R\.\-Tolkien"/, output
-    assert_match /\>J\. R\. R\. Tolkien\</,         output
-  end
-
-  test "page link with custom base path" do
-    ["/wiki", "/wiki/"].each_with_index do |path, i|
-      name = "Bilbo Baggins #{i}"
-      @wiki = Gollum::Wiki.new(@path, :base_path => path)
-      @wiki.write_page(name, :markdown, "a [[#{name}]] b", commit_details)
-
-      page = @wiki.page(name)
-      output = page.formatted_data
-      assert_match /class="internal present"/,        output
-      assert_match /href="\/wiki\/Bilbo-Baggins-\d"/, output
-      assert_match /\>Bilbo Baggins \d\</,            output
-    end
-  end
-
-  test "page link with included #" do
-    @wiki.write_page("Precious #1", :markdown, "a [[Precious #1]] b", commit_details)
-    page   = @wiki.page('Precious #1')
-    output = page.formatted_data
-    assert_match /class="internal present"/, output
-    assert_match /href="\/Precious-%231"/,   output
-  end
-
-  test "page link with extra #" do
-    @wiki.write_page("Potato", :markdown, "a [[Potato#1]] b", commit_details)
-    page   = @wiki.page('Potato')
-    output = page.formatted_data
-    assert_match /class="internal present"/, output
-    assert_match /href="\/Potato#1"/,        output
-  end
-
-  test "external page link" do
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[http://example.com]] b", commit_details)
-
-    page = @wiki.page("Bilbo Baggins")
-    assert_equal "<p>a <a href=\"http://example.com\">http://example.com</a> b</p>", page.formatted_data
-  end
-
-  test "page link with different text" do
-    @wiki.write_page("Potato", :markdown, "a [[Potato Heaad|Potato]] ", commit_details)
-    page = @wiki.page("Potato")
-    output = page.formatted_data
-    assert_equal "<p>a<aclass=\"internalpresent\"href=\"/Potato\">PotatoHeaad</a></p>", normal(output)
-  end
-
-  test "page link with different text on mediawiki" do
-    @wiki.write_page("Potato", :mediawiki, "a [[Potato|Potato Heaad]] ", commit_details)
-    page = @wiki.page("Potato")
-    output = page.formatted_data
-    assert_equal normal("<p>\na <a class=\"internal present\" href=\"/Potato\">Potato Heaad</a> </p>
-"), normal(output)
-  end
-
-  test "wiki link within inline code block" do
-    @wiki.write_page("Potato", :markdown, "`sed -i '' 's/[[:space:]]*$//'`", commit_details)
-    page = @wiki.page("Potato")
-    assert_equal "<p><code>sed -i '' 's/[[:space:]]*$//'</code></p>", page.formatted_data
-  end
-
-  test "wiki link within code block" do
-    @wiki.write_page("Potato", :markdown, "    sed -i '' 's/[[:space:]]*$//'", commit_details)
-    page = @wiki.page("Potato")
-    assert_equal "<pre><code>sed -i '' 's/[[:space:]]*$//'\n</code></pre>", page.formatted_data
-  end
-
-  test "piped wiki link within code block" do
-    @wiki.write_page("Potato", :markdown, "`make a link [[home|sweet home]]`", commit_details)
-    page = @wiki.page("Potato")
-    assert_equal "<p><code>make a link [[home|sweet home]]</code></p>", page.formatted_data
-  end
-
-  #########################################################################
-  #
-  # Images
-  #
-  #########################################################################
-
-  test "image with http url" do
-    ['http', 'https'].each do |scheme|
-      name = "Bilbo Baggins #{scheme}"
-      @wiki.write_page(name, :markdown, "a [[#{scheme}://example.com/bilbo.jpg]] b", commit_details)
-
-      page = @wiki.page(name)
-      output = page.formatted_data
-      assert_equal %{<p>a <img src="#{scheme}://example.com/bilbo.jpg"> b</p>}, output
-    end
-  end
-
-  test "image with extension in caps with http url" do
-    ['http', 'https'].each do |scheme|
-      name = "Bilbo Baggins #{scheme}"
-      @wiki.write_page(name, :markdown, "a [[#{scheme}://example.com/bilbo.JPG]] b", commit_details)
-
-      page = @wiki.page(name)
-      output = page.formatted_data
-      assert_equal %{<p>a <img src="#{scheme}://example.com/bilbo.JPG"> b</p>}, output
-    end
-  end
-
-  test "image with absolute path" do
-    @wiki = Gollum::Wiki.new(@path, :base_path => '/wiki')
-    index = @wiki.repo.index
-    index.add("alpha.jpg", "hi")
-    index.commit("Add alpha.jpg")
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[/alpha.jpg]] [[a | /alpha.jpg]] b", commit_details)
-
-    page = @wiki.page("Bilbo Baggins")
-    assert_equal %{<p>a <img src="/wiki/alpha.jpg"><a href="/wiki/alpha.jpg">a</a> b</p>}, page.formatted_data
-  end
-
-  test "image with relative path on root" do
-    @wiki = Gollum::Wiki.new(@path, :base_path => '/wiki')
-    index = @wiki.repo.index
-    index.add("alpha.jpg", "hi")
-    index.add("Bilbo-Baggins.md", "a [[alpha.jpg]] [[a | alpha.jpg]] b")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    assert_equal %{<p>a <img src="/wiki/alpha.jpg"><a href="/wiki/alpha.jpg">a</a> b</p>}, page.formatted_data
-  end
-
-  test "image with relative path" do
-    @wiki = Gollum::Wiki.new(@path, :base_path => '/wiki')
-    index = @wiki.repo.index
-    index.add("greek/alpha.jpg", "hi")
-    index.add("greek/Bilbo-Baggins.md", "a [[alpha.jpg]] [[a | alpha.jpg]] b")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    output = page.formatted_data
-    assert_equal %{<p>a <img src="/wiki/greek/alpha.jpg"><a href="/wiki/greek/alpha.jpg">a</a> b</p>}, output
-  end
-
-  test "image with absolute path on a preview" do
-    @wiki = Gollum::Wiki.new(@path, :base_path => '/wiki')
-    index = @wiki.repo.index
-    index.add("alpha.jpg", "hi")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.preview_page("Test", "a [[/alpha.jpg]] b", :markdown)
-    assert_equal %{<p>a <img src="/wiki/alpha.jpg"> b</p>}, page.formatted_data
-  end
-
-  test "image with relative path on a preview" do
-    @wiki = Gollum::Wiki.new(@path, :base_path => '/wiki')
-    index = @wiki.repo.index
-    index.add("alpha.jpg", "hi")
-    index.add("greek/alpha.jpg", "hi")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.preview_page("Test", "a [[alpha.jpg]] [[greek/alpha.jpg]] b", :markdown)
-    assert_equal %{<p>a <img src="/wiki/alpha.jpg"><img src="/wiki/greek/alpha.jpg"> b</p>}, page.formatted_data
-  end
-
-  test "image with alt" do
-    content = "a [[alpha.jpg|alt=Alpha Dog]] b"
-    output = %{<p>a <img src="/greek/alpha.jpg" alt="Alpha Dog"> b</p>}
-    relative_image(content, output)
-  end
-
-  test "image with em or px dimension" do
-    %w{em px}.each do |unit|
-      %w{width height}.each do |dim|
-        content = "a [[alpha.jpg|#{dim}=100#{unit}]] b"
-        output = "<p>a <img src=\"/greek/alpha.jpg\" #{dim}=\"100#{unit}\"> b</p>"
-        relative_image(content, output)
-      end
-    end
-  end
-
-  test "image with bogus dimension" do
-    %w{width height}.each do |dim|
-      content = "a [[alpha.jpg|#{dim}=100]] b"
-      output = "<p>a <img src=\"/greek/alpha.jpg\"> b</p>"
-      relative_image(content, output)
-    end
-  end
-
-  test "image with vertical align" do
-    %w{top texttop middle absmiddle bottom absbottom baseline}.each do |align|
-      content = "a [[alpha.jpg|align=#{align}]] b"
-      output = "<p>a <img src=\"/greek/alpha.jpg\" align=\"#{align}\"> b</p>"
-      relative_image(content, output)
-    end
-  end
-
-  test "image with horizontal align" do
-    %w{left center right}.each do |align|
-      content = "a [[alpha.jpg|align=#{align}]] b"
-      output = "<p>a <span class=\"align-#{align}\"><span><img src=\"/greek/alpha.jpg\"></span></span> b</p>"
-      relative_image(content, output)
-    end
-  end
-
-  test "image with float" do
-    content = "a\n\n[[alpha.jpg|float]]\n\nb"
-    output = "<p>a</p>\n\n<p><span class=\"float-left\"><span><img src=\"/greek/alpha.jpg\"></span></span></p>\n\n<p>b</p>"
-    relative_image(content, output)
-  end
-
-  test "image with float and align" do
-    %w{left right}.each do |align|
-      content = "a\n\n[[alpha.jpg|float|align=#{align}]]\n\nb"
-      output = "<p>a</p>\n\n<p><span class=\"float-#{align}\"><span><img src=\"/greek/alpha.jpg\"></span></span></p>\n\n<p>b</p>"
-      relative_image(content, output)
-    end
-  end
-
-  test "image with frame" do
-    content = "a\n\n[[alpha.jpg|frame]]\n\nb"
-    output = "<p>a</p>\n\n<p><span class=\"frame\"><span><img src=\"/greek/alpha.jpg\"></span></span></p>\n\n<p>b</p>"
-    relative_image(content, output)
-  end
-
-  test "absolute image with frame" do
-    content = "a\n\n[[http://example.com/bilbo.jpg|frame]]\n\nb"
-    output = "<p>a</p>\n\n<p><span class=\"frame\"><span><img src=\"http://example.com/bilbo.jpg\"></span></span></p>\n\n<p>b</p>"
-    relative_image(content, output)
-  end
-
-  test "image with frame and alt" do
-    content = "a\n\n[[alpha.jpg|frame|alt=Alpha]]\n\nb"
-    output = "<p>a</p>\n\n<p><span class=\"frame\"><span><img src=\"/greek/alpha.jpg\" alt=\"Alpha\"><span>Alpha</span></span></span></p>\n\n<p>b</p>"
-    relative_image(content, output)
-  end
-
-  #########################################################################
-  #
-  # File links
-  #
-  #########################################################################
-
-  test "file link with absolute path" do
-    index = @wiki.repo.index
-    index.add("alpha.jpg", "hi")
-    index.commit("Add alpha.jpg")
-    @wiki.write_page("Bilbo Baggins", :markdown, "a [[Alpha|/alpha.jpg]] b", commit_details)
-
-    page = @wiki.page("Bilbo Baggins")
-    output = Gollum::Markup.new(page).render
-    assert_equal %{<p>a <a href="/alpha.jpg">Alpha</a> b</p>}, output
-  end
-
-  test "file link with relative path" do
-    index = @wiki.repo.index
-    index.add("greek/alpha.jpg", "hi")
-    index.add("greek/Bilbo-Baggins.md", "a [[Alpha|alpha.jpg]] b")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    output = Gollum::Markup.new(page).render
-    assert_equal %{<p>a <a href="/greek/alpha.jpg">Alpha</a> b</p>}, output
-  end
-
-  test "file link with external path" do
-    index = @wiki.repo.index
-    index.add("greek/Bilbo-Baggins.md", "a [[Alpha|http://example.com/alpha.jpg]] b")
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    assert_equal %{<p>a <a href="http://example.com/alpha.jpg">Alpha</a> b</p>}, page.formatted_data
-  end
-
-  #########################################################################
-  #
-  # Code
-  #
-  #########################################################################
-
-  test "code blocks" do
-    content = "a\n\n```ruby\nx = 1\n```\n\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\">\n<pre>" +
-             "<span class=\"n\">x</span> <span class=\"o\">=</span> " +
-             "<span class=\"mi\">1</span>\n</pre>\n</div>\n\n\n<p>b</p>"
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal output, rendered
-  end
-
-  test "code blocks with carriage returns" do
-    content = "a\r\n\r\n```ruby\r\nx = 1\r\n```\r\n\r\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\">\n<pre>" +
-             "<span class=\"n\">x</span> <span class=\"o\">=</span> " +
-             "<span class=\"mi\">1</span>\n</pre>\n</div>\n\n\n<p>b</p>"
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal output, rendered
-  end
-
-  test "code blocks with two-space indent" do
-    content = "a\n\n```ruby\n  x = 1\n\n  y = 2\n```\n\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\"><pre><span class=\"n\">" +
-             "x</span> <span class=\"o\">=</span> <span class=\"mi\">1" +
-             "</span>\n\n<span class=\"n\">y</span> <span class=\"o\">=" +
-             "</span> <span class=\"mi\">2</span>\n</pre>\n</div>\n\n\n<p>b</p>"
-    compare(content, output)
-  end
-
-  test "code blocks with one-tab indent" do
-    content = "a\n\n```ruby\n\tx = 1\n\n\ty = 2\n```\n\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\"><pre><span class=\"n\">" +
-             "x</span> <span class=\"o\">=</span> <span class=\"mi\">1" +
-             "</span>\n\n<span class=\"n\">y</span> <span class=\"o\">=" +
-             "</span> <span class=\"mi\">2</span>\n</pre>\n</div>\n\n\n<p>b</p>"
-    compare(content, output)
-  end
-
-  test "code blocks with multibyte caracters indent" do
-    content = "a\n\n```ruby\ns = 'やくしまるえつこ'\n```\n\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\">\n<pre><span class=\"n\">" +
-             "s</span> <span class=\"o\">=</span> <span class=\"s1\">'やくしまるえつこ'" +
-             "</span>\n</pre>\n</div>\n\n\n<p>b</p>"
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add alpha.jpg")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render(false, 'utf-8')
-    assert_equal output, rendered
-  end
-
-  test "code blocks with ascii characters" do
-    content = "a\n\n```\n├─foo\n```\n\nb"
-    output = "<p>a</p>\n\n<div class=\"highlight\"><pre>" +
-             "├─<span class=\"n\">foo</span>" +
-             "\n</pre>\n</div>\n\n<p>b</p>"
-    compare(content, output)
-  end
-
-  test "code with wiki links" do
-    content = <<-END
-booya
-
-``` python
-np.array([[2,2],[1,3]],np.float)
-```
-    END
-
-    # rendered with Gollum::Markup
-    page, rendered = render_page(content)
-    assert_markup_highlights_code Gollum::Markup, rendered
-  end
-
-  test "code with trailing whitespace" do
-    content = <<-END
-shoop da woop
-
-``` python 
-np.array([[2,2],[1,3]],np.float)
-```
-    END
-
-    # rendered with Gollum::Markup
-    page, rendered = render_page(content)
-    assert_markup_highlights_code Gollum::Markup, rendered
-  end
-
-  def assert_markup_highlights_code(markup_class, rendered)
-    assert_match /div class="highlight"/, rendered, "#{markup_class} doesn't highlight code\n #{rendered}"
-    assert_match /span class="n"/, rendered, "#{markup_class} doesn't highlight code\n #{rendered}"
-    assert_match /\(\[\[/, rendered, "#{markup_class} parses out wiki links\n#{rendered}"
-  end
-
-  #########################################################################
-  #
-  # Web Sequence Diagrams
-  #
-  #########################################################################
-
-  test "sequence diagram blocks" do
-    content = "a\n\n{{{{{{default\nalice->bob: Test\n}}}}}}\n\nb"
-    output = /.*<img src="http:\/\/www\.websequencediagrams\.com\/\?img=\w{9}" \/>.*/
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add sequence diagram")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_not_nil rendered.match(output)
-  end
-
-  #########################################################################
-  #
-  # Metadata Blocks
-  #
-  #########################################################################
-
-  test "metadata blocks" do
-    content = "a\n\n<!-- ---\ntags: [foo, bar]\n-->\n\nb"
-    output = "<p>a</p>\n\n<p>b</p>"
-    result = {'tags'=>['foo','bar']}
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add metadata")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal output, rendered 
-    assert_equal result, page.meta_data
-  end
-
-  test "metadata blocks with newline" do
-    content = "a\n\n<!--\n---\ntags: [foo, bar]\n-->\n\nb"
-    output = "<p>a</p>\n\n<p>b</p>"
-    result = {'tags'=>['foo','bar']}
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add metadata")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal output, rendered 
-    assert_equal result, page.meta_data
-  end
-
-  test "metadata sanitation" do
-    content = "a\n\n<!-- ---\nfoo: <script>alert('');</script>\n-->\n\nb"
-    output = "<p>a</p>\n\n<p>b</p>"
-    result = {'foo'=>nil}
-
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.md", content)
-    index.commit("Add metadata")
-
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal output, rendered 
-    assert_equal result, page.meta_data
-  end
-
-  #########################################################################
-  #
-  # Various
-  #
-  #########################################################################
-
-  test "strips javscript protocol urls" do
-    content = "[Hack me](javascript:hacked=true)"
-    output = "<p><a>Hackme</a></p>"
-    compare(content, output)
-  end
-
-  test "allows apt uri schemes" do
-    content = "[Hack me](apt:gettext)"
-    output = "<p><a href=\"apt:gettext\">Hackme</a></p>"
-    compare(content, output)
-  end
-
-  test "removes style blocks completely" do
-    content = "<style>body { color: red }</style>foobar"
-    output = "<p>foobar</p>"
-    compare(content, output)
-  end
-
-  test "removes script blocks completely" do
-    content = "<script>alert('hax');</script>foobar"
-    output = "<p>foobar</p>"
-    compare(content, output)
-  end
-
-  test "escaped wiki link" do
-    content = "a '[[Foo]], b"
-    output = "<p>a [[Foo]], b</p>"
-    compare(content, output)
-  end
-
-  test "quoted wiki link" do
-    content = "a '[[Foo]]', b"
-    output = "<p>a '<a class=\"internal absent\" href=\"/Foo\">Foo</a>', b</p>"
-    compare(content, output, 'md', [
-      /class="internal absent"/,
-      /href="\/Foo"/,
-      /\>Foo\</])
-  end
-
-  test "org mode style double links" do
-    content = "a [[http://google.com][Google]] b"
-    output = "<p class=\"title\">a <a href=\"http://google.com\">Google</a> b</p>"
-    compare(content, output, 'org')
-  end
-
-  test "org mode style double file links" do
-    content = "a [[file:f.org][Google]] b"
-    output = "<p class=\"title\">a <a class=\"internal absent\" href=\"/f\">Google</a> b</p>"
-    compare(content, output, 'org')
-  end
-
-  test "short double links" do
-    content = "a [[b]] c"
-    output  = %(<p class="title">a <a class="internal absent" href="/b">b</a> c</p>)
-    compare(content, output, 'org')
-  end
-
-  test "double linked pipe" do
-    content = "a [[|]] b"
-    output  = %(<p class="title">a <a class="internal absent" href="/"></a> b</p>)
-    compare(content, output, 'org')
-  end
-
-  test "id with prefix ok" do
-    content = "h2(example#wiki-foo). xxxx"
-output = %(<h2 class="example" id="wiki-foo">xxxx<a class=\"anchor\" id=\"xxxx\" href=\"#xxxx\"></a></h2>)
-compare(content, output, :textile)
-end
-
-  test "id prefix added" do
-    content = "h2(#foo). xxxx[1]\n\nfn1.footnote"
-    output = "<h2 id=\"wiki-foo\">xxxx" +
-             "<sup class=\"footnote\" id=\"wiki-fnr1\"><a href=\"#wiki-fn1\">1</a></sup>" +
-             "<a class=\"anchor\" id=\"xxxx1\" href=\"#xxxx1\"></a></h2>" +
-             "\n<p class=\"footnote\" id=\"wiki-fn1\"><a href=\"#wiki-fnr1\"><sup>1</sup></a> footnote</p>"
-    compare(content, output, :textile)
-  end
-
-  test "name prefix added" do
-    content = "abc\n\n__TOC__\n\n==Header==\n\nblah"
-    compare content, '', :mediawiki, [
-      /id="wiki-toc"/,
-      /href="#wiki-Header"/,
-      /id="wiki-Header"/,
-      /name="wiki-Header"/
-    ]
-  end
-
-  #########################################################################
-  #
-  # TeX
-  #
-  #########################################################################
-
-  test "TeX block syntax" do
-    content = 'a \[ a^2 \] b'
-    output = "<p>a<imgsrc=\"http://www.mathtran.org/cgi-bin/toy/?D=4;tex=a^2\"alt=\"a^2\">b</p>"
-    compare(content, output, 'md')
-  end
-
-  test "TeX inline syntax" do
-    content = 'a \( a^2 \) b'
-    output = "<p>a<imgsrc=\"http://www.mathtran.org/cgi-bin/toy/?D=2;tex=a^2\"alt=\"a^2\">b</p>"
-    compare(content, output, 'md')
-  end
-
-  #########################################################################
-  # Asciidoc
-  #########################################################################
-
-  test "asciidoc header" do 
-    compare("= Book Title\n\n== Heading", '<div class="sect1"><h2 id="wiki-_heading">Heading<a class="anchor" id="Heading" href="#Heading"></a></h2><div class="sectionbody"></div></div>', 'asciidoc')
-  end
-
-  test "internal links with asciidoc" do 
-    compare("= Book Title\n\n[[anid]]\n== Heading", '<div class="sect1"><h2 id="wiki-anid">Heading<a class="anchor" id="Heading" href="#Heading"></a></h2><div class="sectionbody"></div></div>', 'asciidoc')
-  end
-
-  #########################################################################
-  #
-  # Helpers
-  #
-  #########################################################################
-
-  def render_page(content, ext = "md")
-    index = @wiki.repo.index
-    index.add("Bilbo-Baggins.#{ext}", content)
-    index.commit("Add baggins")
-
-    page = @wiki.page("Bilbo Baggins")
-    [page, Gollum::Markup.new(page).render]
-  end
-
-  def compare(content, output, ext = "md", regexes = [])
-    page, rendered = render_page(content, ext)
-
-    if regexes.empty?
-      assert_equal normal(output), normal(rendered)
-    else
-      output = page.formatted_data
-      regexes.each { |r| assert_match r, output }
-    end
-  end
-
-  def relative_image(content, output)
-    index = @wiki.repo.index
-    index.add("greek/alpha.jpg", "hi")
-    index.add("greek/Bilbo-Baggins.md", content)
-    index.commit("Add alpha.jpg")
-
-    @wiki.clear_cache
-    page = @wiki.page("Bilbo Baggins")
-    rendered = Gollum::Markup.new(page).render
-    assert_equal normal(output), normal(rendered)
-  end
-end