gollum-bibanon 1.3.1

data/test/test_app.rb

@@ -0,0 +1,179 @@
+# ~*~ encoding: utf-8 ~*~
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+context "Frontend" do
+  include Rack::Test::Methods
+
+  setup do
+    @path = cloned_testpath("examples/revert.git")
+    @wiki = Gollum::Wiki.new(@path)
+    Precious::App.set(:gollum_path, @path)
+    Precious::App.set(:wiki_options, {})
+  end
+
+  teardown do
+    FileUtils.rm_rf(@path)
+  end
+
+  test "edits page" do
+    page_1 = @wiki.page('A')
+    post "/edit/A", :content => 'abc',
+      :format => page_1.format, :message => 'def'
+    follow_redirect!
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page_2 = @wiki.page(page_1.name)
+    assert_equal 'abc', page_2.raw_data
+    assert_equal 'def', page_2.version.message
+    assert_not_equal page_1.version.sha, page_2.version.sha
+  end
+
+  test "edits page footer and sidebar" do
+    commits = @wiki.repo.commits('master').size
+    page_1  = @wiki.page('A')
+    foot_1  = page_1.footer
+    side_1  = page_1.sidebar
+
+    post "/edit/A",
+      :footer => 'footer', :page => "A", :sidebar => 'sidebar', :message => 'def'
+    follow_redirect!
+    assert_equal "/A", last_request.fullpath
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page_2 = @wiki.page(page_1.name)
+    foot_2 = page_2.footer
+    side_2 = page_2.sidebar
+    assert_equal page_1.raw_data, page_2.raw_data
+
+    assert_equal 'footer', foot_2.raw_data
+    assert_equal 'def',    foot_2.version.message
+    assert_not_equal foot_1.version.sha, foot_2.version.sha
+
+    assert_equal 'sidebar', side_2.raw_data
+    assert_equal 'def',     side_2.version.message
+    assert_not_equal side_1.version.sha, side_2.version.sha
+    assert_equal commits+1, @wiki.repo.commits('master').size
+  end
+
+  test "renames page" do
+    page_1 = @wiki.page('B')
+    post "/edit/B", :content => 'abc',
+      :rename => "C",
+      :format => page_1.format, :message => 'def'
+    follow_redirect!
+    assert_equal "/C", last_request.fullpath
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    assert_nil @wiki.page("B")
+    page_2 = @wiki.page('C')
+    assert_equal 'abc', page_2.raw_data
+    assert_equal 'def', page_2.version.message
+    assert_not_equal page_1.version.sha, page_2.version.sha
+  end
+
+  test "creates page" do
+    post "/create", :content => 'abc', :page => "D",
+      :format => 'markdown', :message => 'def'
+    follow_redirect!
+    assert last_response.ok?
+
+    page = @wiki.page('D')
+    assert_equal 'abc', page.raw_data
+    assert_equal 'def', page.version.message
+  end
+
+  test "redirects to create on non-existant page" do
+    name = "E"
+    get "/#{name}"
+    follow_redirect!
+    assert_equal "/create/#{name}", last_request.fullpath
+    assert last_response.ok?
+  end
+
+  test "edit redirects to create on non-existant page" do
+    name = "E"
+    get "/edit/#{name}"
+    follow_redirect!
+    assert_equal "/create/#{name}", last_request.fullpath
+    assert last_response.ok?
+  end  
+
+  test "create redirects to page if already exists" do
+    name = "A"
+    get "/create/#{name}"
+    follow_redirect!
+    assert_equal "/#{name}", last_request.fullpath
+    assert last_response.ok?
+  end
+ 
+  test "guards against creation of existing page" do
+    name = "A"
+    post "/create", :content => 'abc', :page => name,
+      :format => 'markdown', :message => 'def'
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page = @wiki.page(name)
+    assert_not_equal 'abc', page.raw_data
+  end
+
+  test "previews content" do
+    post "/preview", :content => 'abc', :format => 'markdown'
+    assert last_response.ok?
+  end
+
+  test "previews content on the first page of an empty wiki" do
+    @path = cloned_testpath("examples/empty.git")
+    @wiki = Gollum::Wiki.new(@path)
+    Precious::App.set(:gollum_path, @path)
+    Precious::App.set(:wiki_options, {})
+
+    post "/preview", :content => 'abc', :format => 'markdown'
+    assert last_response.ok?
+  end
+
+
+  test "reverts single commit" do
+    page1 = @wiki.page('B')
+
+    post "/revert/B/7c45b5f16ff3bae2a0063191ef832701214d4df5"
+    follow_redirect!
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page2 = @wiki.page('B')
+    assert_not_equal page1.version.sha, page2.version.sha
+    assert_equal "INITIAL", page2.raw_data.strip
+  end
+
+  test "reverts multiple commits" do
+    page1 = @wiki.page('A')
+
+    post "/revert/A/fc66539528eb96f21b2bbdbf557788fe8a1196ac/b26b791cb7917c4f37dd9cb4d1e0efb24ac4d26f"
+    follow_redirect!
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page2 = @wiki.page('A')
+    assert_not_equal page1.version.sha, page2.version.sha
+    assert_equal "INITIAL", page2.raw_data.strip
+  end
+
+  test "cannot revert conflicting commit" do
+    page1 = @wiki.page('A')
+
+    post "/revert/A/302a5491a9a5ba12c7652ac831a44961afa312d2"
+    assert last_response.ok?
+
+    @wiki.clear_cache
+    page2 = @wiki.page('A')
+    assert_equal page1.version.sha, page2.version.sha
+  end
+
+  def app
+    Precious::App
+  end
+end

data/test/test_committer.rb

@@ -0,0 +1,64 @@
+# ~*~ 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']
+    email = @wiki.repo.config['user.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 = '1db89ebba7e2c14d93b94ff98cfa3708a4f0d4e3'
+    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

@@ -0,0 +1,27 @@
+# ~*~ 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_git_access.rb

@@ -0,0 +1,52 @@
+# ~*~ 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"=>"1db89ebba7e2c14d93b94ff98cfa3708a4f0d4e3"}, @access.ref_map)
+
+    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

@@ -0,0 +1,580 @@
+# ~*~ 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)
+    @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
+
+  #########################################################################
+  #
+  # 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 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
+
+    if Gollum.const_defined?(:MarkupGFM)
+      rendered_gfm = Gollum::MarkupGFM.new(page).render
+      assert_markup_highlights_code Gollum::MarkupGFM, rendered_gfm
+    end
+  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
+
+  #########################################################################
+  #
+  # Various
+  #
+  #########################################################################
+
+  test "strips javscript protocol urls" do
+    content = "[Hack me](javascript:hacked=true)"
+    output = "<p><a>Hackme</a></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</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></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=\"/_tex.png?type=block&data=YV4y\"alt=\"a^2\">b</p>"
+    compare(content, output, 'md')
+  end
+
+  test "TeX inline syntax" do
+    content = 'a \( a^2 \) b'
+    output = "<p>a<imgsrc=\"/_tex.png?type=inline&data=YV4y\"alt=\"a^2\">b</p>"
+    compare(content, output, 'md')
+  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