dolt 0.1.1 → 0.2.0

data/test/dolt/sinatra/actions_test.rb

@@ -33,35 +33,86 @@ class DummySinatraApp
   end
 
   def response
-    @response ||= {}
+    if !@response
+      @response = {}
+      def @response.status; @status; end
+      def @response.status=(status); @status = status; end
+    end
+    @response
+  end
+
+  def tree_url(repo, ref, path)
+    "/#{repo}/tree/#{ref}:#{path}"
+  end
+
+  def blob_url(repo, ref, path)
+    "/#{repo}/blob/#{ref}:#{path}"
   end
 end
 
 class Renderer
   def initialize(body = ""); @body = body; end
 
-  def render(action, data)
+  def render(action, data, options = {})
     @action = action
     @data = data
-    @body
+    "#{action}:#@body"
+  end
+end
+
+class BlobStub
+  def is_a?(type)
+    type == Rugged::Blob
+  end
+end
+
+class TreeStub
+  def is_a?(type)
+    type == Rugged::Tree
   end
 end
 
 class Actions
   attr_reader :repo, :ref, :path
 
-  def blob(repo, ref, path)
+  def initialize(response)
+    @response = response
+  end
+
+  def blob(repo, ref, path, &block)
+    respond(:blob, repo, ref, path, &block)
+  end
+
+  def tree(repo, ref, path, &block)
+    respond(:tree, repo, ref, path, &block)
+  end
+
+  def raw(repo, ref, path, &block)
+    respond(:raw, repo, ref, path, &block)
+  end
+
+  def blame(repo, ref, path, &block)
+    respond(:blame, repo, ref, path, &block)
+  end
+
+  def history(repo, ref, path, limit, &block)
+    respond(:history, repo, ref, path, &block)
+  end
+
+  def respond(type, repo, ref, path, &block)
     @repo = repo
     @ref = ref
     @path = path
-    yield nil, { :ref => ref, :repository => repo, :blob => "Blob" }
+    data = { :ref => ref, :repository => repo }
+    data[type] = @response
+    block.call(nil, data)
   end
 end
 
 describe Dolt::Sinatra::Actions do
   describe "#blob" do
     it "delegates to actions" do
-      actions = Actions.new
+      actions = Actions.new(BlobStub.new)
       app = DummySinatraApp.new(actions, Renderer.new)
       app.blob("gitorious", "master", "app/models/repository.rb")
 
@@ -71,11 +122,120 @@ describe Dolt::Sinatra::Actions do
     end
 
     it "renders the blob template as html" do
-      app = DummySinatraApp.new(Actions.new, Renderer.new("Blob"))
+      app = DummySinatraApp.new(Actions.new(BlobStub.new), Renderer.new("Blob"))
       app.blob("gitorious", "master", "app/models/repository.rb")
 
       assert_equal "text/html", app.response["Content-Type"]
-      assert_equal "Blob", app.body
+      assert_equal "blob:Blob", app.body
+    end
+
+    it "redirects tree views to tree action" do
+      app = DummySinatraApp.new(Actions.new(TreeStub.new), Renderer.new("Blob"))
+      app.blob("gitorious", "master", "app/models")
+
+      assert_equal 302, app.response.status
+      assert_equal "/gitorious/tree/master:app/models", app.response["Location"]
+      assert_equal "", app.body
+    end
+  end
+
+  describe "#tree" do
+    it "delegates to actions" do
+      actions = Actions.new(TreeStub.new)
+      app = DummySinatraApp.new(actions, Renderer.new)
+      app.tree("gitorious", "master", "app/models")
+
+      assert_equal "gitorious", actions.repo
+      assert_equal "master", actions.ref
+      assert_equal "app/models", actions.path
+    end
+
+    it "renders the tree template as html" do
+      app = DummySinatraApp.new(Actions.new(TreeStub.new), Renderer.new("Tree"))
+      app.tree("gitorious", "master", "app/models")
+
+      assert_equal "text/html", app.response["Content-Type"]
+      assert_equal "tree:Tree", app.body
+    end
+
+    it "redirects blob views to blob action" do
+      app = DummySinatraApp.new(Actions.new(BlobStub.new), Renderer.new("Tree"))
+      app.tree("gitorious", "master", "app/models/repository.rb")
+
+      location = app.response["Location"]
+      assert_equal 302, app.response.status
+      assert_equal "/gitorious/blob/master:app/models/repository.rb", location
+      assert_equal "", app.body
+    end
+  end
+
+  describe "#raw" do
+    it "delegates to actions" do
+      actions = Actions.new(BlobStub.new)
+      app = DummySinatraApp.new(actions, Renderer.new)
+      app.raw("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "gitorious", actions.repo
+      assert_equal "master", actions.ref
+      assert_equal "app/models/repository.rb", actions.path
+    end
+
+    it "renders the raw template as text" do
+      app = DummySinatraApp.new(Actions.new(BlobStub.new), Renderer.new("Text"))
+      app.raw("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "text/plain", app.response["Content-Type"]
+      assert_equal "raw:Text", app.body
+    end
+
+    it "redirects tree views to tree action" do
+      app = DummySinatraApp.new(Actions.new(TreeStub.new), Renderer.new("Tree"))
+      app.raw("gitorious", "master", "app/models")
+
+      location = app.response["Location"]
+      assert_equal 302, app.response.status
+      assert_equal "/gitorious/tree/master:app/models", location
+      assert_equal "", app.body
+    end
+  end
+
+  describe "#blame" do
+    it "delegates to actions" do
+      actions = Actions.new(BlobStub.new)
+      app = DummySinatraApp.new(actions, Renderer.new)
+      app.blame("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "gitorious", actions.repo
+      assert_equal "master", actions.ref
+      assert_equal "app/models/repository.rb", actions.path
+    end
+
+    it "renders the blame template as text" do
+      app = DummySinatraApp.new(Actions.new(BlobStub.new), Renderer.new("Text"))
+      app.blame("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "text/html", app.response["Content-Type"]
+      assert_equal "blame:Text", app.body
+    end
+  end
+
+  describe "#history" do
+    it "delegates to actions" do
+      actions = Actions.new(BlobStub.new)
+      app = DummySinatraApp.new(actions, Renderer.new)
+      app.history("gitorious", "master", "app/models/repository.rb", 10)
+
+      assert_equal "gitorious", actions.repo
+      assert_equal "master", actions.ref
+      assert_equal "app/models/repository.rb", actions.path
+    end
+
+    it "renders the commits template as text" do
+      app = DummySinatraApp.new(Actions.new(BlobStub.new), Renderer.new("Text"))
+      app.history("gitorious", "master", "app/models/repository.rb", 10)
+
+      assert_equal "text/html", app.response["Content-Type"]
+      assert_equal "commits:Text", app.body
     end
   end
 end

data/test/dolt/template_renderer_test.rb

@@ -24,6 +24,8 @@ module ViewHelper
 end
 
 describe Dolt::TemplateRenderer do
+  before { @root = "/dolt/views" }
+
   it "reads template from file" do
     File.expects(:read).with("/dolt/views/file.erb").returns("")
     renderer = Dolt::TemplateRenderer.new("/dolt/views")
@@ -32,13 +34,13 @@ describe Dolt::TemplateRenderer do
 
   it "renders template with locals" do
     File.stubs(:read).returns("<%= name %>!")
-    renderer = Dolt::TemplateRenderer.new("/dolt/views")
+    renderer = Dolt::TemplateRenderer.new(@root)
 
     assert_equal "Chris!", renderer.render(:file, { :name => "Chris"})
   end
 
   it "caches template in memory" do
-    renderer = Dolt::TemplateRenderer.new("/dolt/views")
+    renderer = Dolt::TemplateRenderer.new(@root)
     File.stubs(:read).returns("Original")
     renderer.render(:file)
     File.stubs(:read).returns("Updated")
@@ -47,7 +49,7 @@ describe Dolt::TemplateRenderer do
   end
 
   it "does not cache template in memory when configured not to" do
-    renderer = Dolt::TemplateRenderer.new("/dolt/views", :cache => false)
+    renderer = Dolt::TemplateRenderer.new(@root, :cache => false)
     File.stubs(:read).returns("Original")
     renderer.render(:file)
     File.stubs(:read).returns("Updated")
@@ -63,14 +65,33 @@ describe Dolt::TemplateRenderer do
     assert_equal "I give you: Template", renderer.render(:file)
   end
 
-  it "renders str templates" do
+  it "renders template once without layout" do
+    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
+    File.stubs(:read).with("/file.erb").returns("Template")
+    File.stubs(:read).with("/layout.erb").returns("I give you: <%= yield %>")
+
+    assert_equal "Template", renderer.render(:file, {}, :layout => nil)
+  end
+
+  it "renders template once with different layout" do
+    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
+    File.stubs(:read).with("/file.erb").returns("Template")
+    File.stubs(:read).with("/layout.erb").returns("I give you: <%= yield %>")
+    File.stubs(:read).with("/layout2.erb").returns("I present you: <%= yield %>")
+
+    html = renderer.render(:file, {}, :layout => "layout2")
+
+    assert_equal "I present you: Template", html
+  end
+
+  it "renders templates of specific type" do
     renderer = Dolt::TemplateRenderer.new("/", :type => :str)
     File.stubs(:read).with("/file.str").returns("Hey!")
 
     assert_equal "Hey!", renderer.render(:file)
   end
 
-  it "renders with helper module" do
+  it "renders with helper object" do
     renderer = Dolt::TemplateRenderer.new("/")
     renderer.helper(ViewHelper)
     File.stubs(:read).with("/file.erb").returns("Say it: <%= say_it %>")
@@ -78,11 +99,24 @@ describe Dolt::TemplateRenderer do
     assert_equal "Say it: YES", renderer.render(:file)
   end
 
-  it "configures the renderer" do
-    renderer = Dolt::TemplateRenderer.new("/", { :attributes => { :stuff => "THING" } })
-    renderer.helper(ViewHelper)
-    File.stubs(:read).with("/file.erb").returns("<%= stuff %>")
+  it "does not leak state across render calls" do
+    renderer = Dolt::TemplateRenderer.new("/")
+    File.stubs(:read).with("/file.erb").returns(<<-TEMPLATE)
+<%= @response %><% @response = "NO" %><%= @response %>
+    TEMPLATE
+
+    assert_equal "NO", renderer.render(:file)
+    assert_equal "NO", renderer.render(:file)
+  end
+
+  it "shares state between template and layout" do
+    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
+    File.stubs(:read).with("/file.erb").returns(<<-TEMPLATE)
+<% @response = "NO" %><h1><%= @response %></h1>
+    TEMPLATE
+    tpl = "<title><%= @response %></title><%= yield %>"
+    File.stubs(:read).with("/layout.erb").returns(tpl)
 
-    assert_equal "THING", renderer.render(:file)
+    assert_equal "<title>NO</title><h1>NO</h1>\n", renderer.render(:file)
   end
 end

data/test/dolt/templates/blame_test.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+#--
+#   Copyright (C) 2012 Gitorious AS
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+require "test_helper"
+require "dolt/template_renderer"
+require "dolt/view"
+
+class Blame
+  attr_reader :chunks
+  def initialize(chunks); @chunks = chunks; end
+end
+
+describe "blame template" do
+  include Dolt::ViewTest
+
+  before do
+    @repo = "the-dolt"
+    @template_root = File.join(File.dirname(__FILE__), "..", "..", "..", "views")
+    @committer = {
+      :name => "Christian Johansen",
+      :mail => "christian@cjohansen.no",
+      :time => Time.now
+    }
+  end
+
+  def render(path, blame, options = {})
+    renderer = prepare_renderer(@template_root, options)
+    renderer.render(:blame, {
+                      :blame => blame,
+                      :repository => @repo,
+                      :ref => options[:ref] || "master",
+                      :path => path
+                    })
+  end
+
+  it "renders blame" do
+    blob = Blame.new([{ :oid => "0123456", :committer => @committer, :lines => [] }])
+    markup = render("app/models/repository.rb", blob)
+
+    assert_match /<table class="gts-code-listing">/, markup
+  end
+end

data/test/dolt/{views → templates}/blob_test.rb

@@ -16,40 +16,40 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 require "test_helper"
-require "dolt/git/blob"
-require "dolt/git/repository"
 require "dolt/template_renderer"
 require "dolt/view"
 
+class Blob
+  attr_reader :content
+  def initialize(content); @content = content; end
+end
+
 describe "blob template" do
+  include Dolt::ViewTest
+
   before do
-    @repo = Dolt::Git::Repository.new("the-dolt")
+    @repo = "the-dolt"
     @template_root = File.join(File.dirname(__FILE__), "..", "..", "..", "views")
   end
 
-  def render(blob, options = {})
-    options[:attributes] = options[:attributes] || {}
-    attrs = options[:attributes]
-    if !attrs.key?(:multi_repo_mode); attrs[:multi_repo_mode] = true; end
-    renderer = Dolt::TemplateRenderer.new(@template_root, options)
-    renderer.helper(Dolt::View)
+  def render(path, blob, options = {}, helpers = nil)
+    renderer = prepare_renderer(@template_root, options, helpers)
     renderer.render(:blob, {
                       :blob => blob,
                       :repository => @repo,
-                      :ref => options[:ref] || "master"
+                      :ref => options[:ref] || "master",
+                      :path => path
                     })
   end
 
   it "renders blob without errors" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob)
+    markup = render("file.txt", Blob.new("Something something"))
 
     assert_match /Something something/, markup
   end
 
   it "renders blob with line numbers" do
-    blob = Dolt::Git::Blob.new("file.txt", "One\nTwo\nThree")
-    markup = render(blob)
+    markup = render("file.txt", Blob.new("One\nTwo\nThree"))
 
     assert_match /<li.*One.*<\/li>/, markup
     assert_match /<li.*Two.*<\/li>/, markup
@@ -57,40 +57,28 @@ describe "blob template" do
   end
 
   it "renders blob with layout" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob, :layout => "layout")
+    markup = render("file.txt", Blob.new("Something something"), :layout => "layout")
 
     assert_match /Something something/, markup
   end
 
   it "renders repo title in page" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob, :layout => "layout")
+    @repo = "my-magic-repo"
+    markup = render("file.txt", Blob.new("Something something"), :layout => "layout")
 
-    assert_match @repo.name, markup
+    assert_match "my-magic-repo", markup
   end
 
   it "renders links to other views" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob)
+    markup = render("file.txt", Blob.new("Something something"))
 
     assert_match "/the-dolt/blame/master:file.txt", markup
     assert_match "/the-dolt/history/master:file.txt", markup
     assert_match "/the-dolt/raw/master:file.txt", markup
   end
 
-  it "renders links to other views in single repo mode" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob, { :attributes => { :multi_repo_mode => false } })
-
-    assert_match "\"/blame/master:file.txt", markup
-    assert_match "\"/history/master:file.txt", markup
-    assert_match "\"/raw/master:file.txt", markup
-  end
-
   it "renders links to other views for correct ref" do
-    blob = Dolt::Git::Blob.new("file.txt", "Something something")
-    markup = render(blob, :ref => "123bc21")
+    markup = render("file.txt", Blob.new("Something something"), :ref => "123bc21")
 
     assert_match "/the-dolt/blame/123bc21:file.txt", markup
     assert_match "/the-dolt/history/123bc21:file.txt", markup
@@ -98,11 +86,33 @@ describe "blob template" do
   end
 
   it "renders the path clickable" do
-    blob = Dolt::Git::Blob.new("some/deeply/nested/file.txt", "Something something")
-    markup = render(blob)
+    markup = render("some/deeply/nested/file.txt", Blob.new("Something something"))
 
     assert_match 'href="/the-dolt/tree/master:some"', markup
     assert_match 'href="/the-dolt/tree/master:some/deeply"', markup
     assert_match 'href="/the-dolt/tree/master:some/deeply/nested"', markup
   end
+
+  describe "with smart blob rendering" do
+    include Dolt::Html
+
+    before do
+      @helpers = [Dolt::View::SingleRepository,
+                  Dolt::View::Breadcrumb,
+                  Dolt::View::Blob,
+                  Dolt::View::SmartBlobRenderer]
+    end
+
+    it "renders markdown as html" do
+      markup = render("file.md", Blob.new("# Cool"), {}, @helpers)
+      assert_equal 1, select(markup, "h1").length
+    end
+
+    it "syntax highlights ruby" do
+      blob = Blob.new("class Person\n  attr_reader :name\nend")
+      markup = render("file.rb", blob, {}, @helpers)
+
+      assert_equal 0, select(markup, "h1").length
+    end
+  end
 end