dolt 0.1.0 → 0.1.1

data/bin/dolt

@@ -4,7 +4,7 @@ require "sinatra/base"
 require "dolt/repo_actions"
 require "dolt/template_renderer"
 require "dolt/view"
-require "dolt/git/file_system_repository_resolver"
+require "dolt/disk_repo_resolver"
 
 if ARGV.length == 0
   puts("Dolt should be run with a directory as its sole argument")
@@ -37,8 +37,12 @@ end
 base = File.join(File.dirname(__FILE__), "..")
 
 template_root = File.join(base, "views")
-options = { :cache => false, :layout => "layout" }
-view = Dolt::TemplateRenderer.new(template_root, options)
+view = Dolt::TemplateRenderer.new(template_root, {
+  :cache => false,
+  :layout => "layout",
+  :attributes => { :multi_repo_mode => !is_git_repo?(ARGV[0]) }
+})
+
 view.helper(Dolt::View)
 
 Sinatra::Base.set(:public_folder, File.join(base, "vendor/ui"))

data/lib/dolt/git/blob.rb

@@ -16,16 +16,18 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 module Dolt
-  class Blob
-    attr_reader :path, :raw, :repo
+  module Git
+    class Blob
+      attr_reader :path, :raw, :repo
 
-    def initialize(path, raw)
-      @path = path
-      @raw = raw
-    end
+      def initialize(path, raw)
+        @path = path
+        @raw = raw
+      end
 
-    def lines
-      raw.split("\n")
+      def lines
+        raw.split("\n")
+      end
     end
   end
 end

data/lib/dolt/git/repository.rb

@@ -17,6 +17,7 @@
 #++
 require "dolt/async/when"
 require "dolt/git/blob"
+require "dolt/git/tree"
 
 module Dolt
   module Git
@@ -29,19 +30,30 @@ module Dolt
       end
 
       def blob(path, ref = "HEAD")
-        gitop = git.show(path, ref)
+        async_git(git.show(path, ref)) do |data, status|
+          Dolt::Git::Blob.new(path, data)
+        end
+      end
+
+      def tree(path, ref = "HEAD")
+        async_git(git.ls_tree(path, ref)) do |data, status|
+          Dolt::Git::Tree.parse(path, data)
+        end
+      end
+
+      private
+      def git; @git; end
+
+      def async_git(gitop, &block)
         deferred = When::Deferred.new
 
         gitop.callback do |data, status|
-          deferred.resolve(Dolt::Blob.new(path, data))
+          deferred.resolve(block.call(data, status))
         end
 
         gitop.errback { |err| deferred.reject(err) }
         deferred.promise
       end
-
-      private
-      def git; @git; end
     end
   end
 end

data/lib/dolt/git/shell.rb

@@ -29,6 +29,10 @@ module Dolt
         git("show", "#{ref}:#{path}")
       end
 
+      def ls_tree(path, ref)
+        git("ls-tree", ref, path.sub(/(^\.?\/)?/, "./").sub(/\/?$/, "/"))
+      end
+
       def git(command, *args)
         base = "git --git-dir #{@git_dir} --work-tree #{@work_tree}"
         cmd = "#{base} #{command} #{args.join(' ')}".strip

data/lib/dolt/git/tree.rb

@@ -0,0 +1,65 @@
+# 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/>.
+#++
+module Dolt
+  module Git
+    class Tree
+      attr_reader :path, :entries
+
+      def initialize(path, entries)
+        @path = path
+        @entries = entries
+      end
+
+      def self.parse(path, ls_tree_payload)
+        path = path == "" ? "./" : path
+
+        entries = ls_tree_payload.split("\n").collect do |line|
+          pieces = line.split(/\s+/)
+          klass = pieces[1] == "blob" ? File : Dir
+          klass.new(pieces[3], pieces[2], pieces[0])
+        end
+
+        dirs = entries.reject { |e| e.file? }.sort_by(&:path)
+        files = entries.reject { |e| e.dir? }.sort_by(&:path)
+        new(path, dirs + files)
+      end
+
+      class Entry
+        attr_reader :full_path, :path, :sha, :mode
+
+        def initialize(path, sha, mode)
+          @full_path = path
+          @path = ::File.basename(path)
+          @sha = sha
+          @mode = mode
+        end
+
+        def file?; false; end
+        def dir?; false; end
+      end
+
+      class File < Entry
+        def file?; true; end
+      end
+
+      class Dir < Entry
+        def dir?; true; end
+      end
+    end
+  end
+end

data/lib/dolt/repo_actions.rb

@@ -23,7 +23,7 @@ module Dolt
       @repo_resolver = repo_resolver
     end
 
-    def blob(repo, ref, path, &block)
+    def blob(repo, path, ref, &block)
       repository = repo_resolver.resolve(repo)
       d = repository.blob(path, ref)
       d.callback do |blob, status|
@@ -35,6 +35,18 @@ module Dolt
       d.errback { |err| block.call(err, nil) }
     end
 
+    def tree(repo, path, ref, &block)
+      repository = repo_resolver.resolve(repo)
+      d = repository.tree(path, ref)
+      d.callback do |tree, status|
+        block.call(nil, {
+                     :tree => tree,
+                     :repository => repository,
+                     :ref => ref })
+      end
+      d.errback { |err| block.call(err, nil) }
+    end
+
     private
     def repo_resolver; @repo_resolver; end
   end

data/lib/dolt/sinatra/actions.rb

@@ -23,8 +23,8 @@ module Dolt
         body("Process failed with exit code \n#{status.exitstatus}")
       end
 
-      def blob(repo, ref, path)
-        actions.blob(repo, ref, path) do |status, data|
+      def blob(repo, path, ref)
+        actions.blob(repo, path, ref) do |status, data|
           if status.nil?
             response["Content-Type"] = "text/html"
             body(renderer.render(:blob, data))
@@ -33,6 +33,17 @@ module Dolt
           end
         end
       end
+
+      def tree(repo, path, ref)
+        actions.tree(repo, path, ref) do |status, data|
+          if status.nil?
+            response["Content-Type"] = "text/html"
+            body(renderer.render(:tree, data))
+          else
+            error(status)
+          end
+        end
+      end
     end
   end
 end

data/lib/dolt/sinatra/multi_repo_browser.rb

@@ -25,12 +25,25 @@ module Dolt
         body("<h1>Welcome to Dolt</h1>")
       end
 
+      aget "/*/tree/*:*" do
+        tree(params[:splat][0], params[:splat][2], params[:splat][1])
+      end
+
+      aget "/*/tree/*" do
+        force_ref(params[:splat], "tree", "master")
+      end
+
       aget "/*/blob/*:*" do
-        blob(*params[:splat])
+        blob(params[:splat][0], params[:splat][2], params[:splat][1])
       end
 
       aget "/*/blob/*" do
-        redirect(params[:splat].shift + "/blob/master:" + params[:splat].join)
+        force_ref(params[:splat], "blob", "master")
+      end
+
+      private
+      def force_ref(args, action, ref)
+        redirect(args.shift + "/#{action}/#{ref}:" + args.join)
       end
     end
   end

data/lib/dolt/sinatra/single_repo_browser.rb

@@ -28,16 +28,29 @@ module Dolt
       end
 
       aget "/" do
-        redirect("/blob/master:Readme.md")
+        redirect("/tree/master:")
+      end
+
+      aget "/tree/*:*" do
+        tree(repo, params[:splat][1], params[:splat][0])
+      end
+
+      aget "/tree/*" do
+        force_ref(params[:splat], "tree", "master")
       end
 
       aget "/blob/*:*" do
         ref, path = params[:splat]
-        blob(repo, ref, path)
+        blob(repo, path, ref)
       end
 
       aget "/blob/*" do
-        redirect("/blob/master:" + params[:splat].join)
+        force_ref(params[:splat], "blob", "master")
+      end
+
+      private
+      def force_ref(args, action, ref)
+        redirect("/#{action}/#{ref}:" + args.join)
       end
     end
   end

data/lib/dolt/template_renderer.rb

@@ -25,6 +25,7 @@ module Dolt
       @layout = opt[:layout]
       @type = opt[:type] || "erb"
       @context_class = Class.new
+      @attributes = opt[:attributes] || {}
     end
 
     def helper(helper_module)
@@ -32,6 +33,7 @@ module Dolt
     end
 
     def render(template, locals = {})
+      locals = locals.merge(attributes)
       context = context_class.new
       content = load(template).render(context, locals)
 
@@ -56,5 +58,6 @@ module Dolt
     def layout; @layout; end
     def type; @type; end
     def context_class; @context_class; end
+    def attributes; @attributes; end
   end
 end

data/lib/dolt/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Dolt
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/dolt/view.rb

@@ -20,8 +20,9 @@ require "dolt/view/highlighter"
 
 module Dolt
   module View
-    def breadcrumb(repository, ref, path)
-      Dolt::View::Breadcrumb.new.render(repository, ref, path)
+    def breadcrumb(repository, path, ref, options = {})
+      bc = Dolt::View::Breadcrumb.new(:multi_repo_mode => options[:multi_repo_mode])
+      bc.render(repository, ref, path)
     end
 
     def multiline(blob, options = {})
@@ -54,5 +55,27 @@ module Dolt
       suffix = path.split(".").pop
       Dolt::View::Highlighter.lexer(suffix)
     end
+
+    def tree_url(repository, entry, ref, multi_repo_mode)
+      action = entry.file? ? "blob" : "tree"
+      repo_url(repository, "/#{action}/#{ref}:#{entry.full_path}", multi_repo_mode)
+    end
+
+    def blame_url(repository, blob, ref, multi_repo_mode)
+      repo_url(repository, "/blame/#{ref}:#{blob.path}", multi_repo_mode)
+    end
+
+    def history_url(repository, blob, ref, multi_repo_mode)
+      repo_url(repository, "/history/#{ref}:#{blob.path}", multi_repo_mode)
+    end
+
+    def raw_url(repository, blob, ref, multi_repo_mode)
+      repo_url(repository, "/raw/#{ref}:#{blob.path}", multi_repo_mode)
+    end
+
+    def repo_url(repository, url, multi_repo_mode)
+      prefix = multi_repo_mode ? "/#{repository.name}" : ""
+      "#{prefix}#{url}"
+    end
   end
 end

data/lib/dolt/view/breadcrumb.rb

@@ -18,13 +18,19 @@
 module Dolt
   module View
     class Breadcrumb
+      attr_reader :multi_repo_mode
+
+      def initialize(options = {})
+        @multi_repo_mode = options[:multi_repo_mode]
+      end
+
       def render(repository, ref, path)
         dirs = path.split("/")
         filename = dirs.pop
         dir_html = accumulate_dirs(dirs, repository.name, ref)
         <<-HTML
           <ul class="breadcrumb">
-            <li><a href="/files"><i class="icon icon-file"></i></a></li>
+            <li><a href="#{prefix(repository)}/tree/#{ref}:"><i class="icon icon-file"></i></a></li>
             #{dir_html}<li class="active">#{filename}</li>
           </ul>
         HTML
@@ -35,10 +41,13 @@ module Dolt
         accumulated = []
         dir_html = dirs.inject("") do |html, dir|
           accumulated << dir
-          "#{html}<li><a href=\"/#{repo}/tree/#{ref}:#{accumulated.join('/')}\">" +
+          "#{html}<li><a href=\"#{prefix(repo)}/tree/#{ref}:#{accumulated.join('/')}\">" +
             "#{dir}<span class=\"divider\">/</span></a></li>"
         end
+      end
 
+      def prefix(repo)
+        multi_repo_mode ? "/#{repo}" : ""
       end
     end
   end

data/lib/dolt/view/highlighter.rb

@@ -47,3 +47,6 @@ module Dolt
 end
 
 Dolt::View::Highlighter.add_lexer_alias("yml", "yaml")
+Dolt::View::Highlighter.add_lexer_alias("Rakefile", "rb")
+Dolt::View::Highlighter.add_lexer_alias("Gemfile", "rb")
+Dolt::View::Highlighter.add_lexer_alias("gemspec", "rb")

data/test/dolt/git/blob_test.rb

@@ -18,10 +18,10 @@
 require "test_helper"
 require "dolt/git/blob"
 
-describe Dolt::Blob do
+describe Dolt::Git::Blob do
   describe "#raw" do
     it "returns full raw blob" do
-      blob = Dolt::Blob.new("file.txt", "Something something")
+      blob = Dolt::Git::Blob.new("file.txt", "Something something")
 
       assert_equal "Something something", blob.raw
     end
@@ -29,19 +29,19 @@ describe Dolt::Blob do
 
   describe "#lines" do
     it "returns empty array for empty blob" do
-      blob = Dolt::Blob.new("file.txt", "")
+      blob = Dolt::Git::Blob.new("file.txt", "")
 
       assert_equal [], blob.lines
     end
 
     it "returns array of one line" do
-      blob = Dolt::Blob.new("file.txt", "Something something")
+      blob = Dolt::Git::Blob.new("file.txt", "Something something")
 
       assert_equal ["Something something"], blob.lines
     end
 
     it "returns array of lines" do
-      blob = Dolt::Blob.new("file.txt", "Something\nsomething\nYup")
+      blob = Dolt::Git::Blob.new("file.txt", "Something\nsomething\nYup")
 
       assert_equal ["Something", "something", "Yup"], blob.lines
     end

data/test/dolt/git/repository_test.rb

@@ -28,7 +28,15 @@ class FakeGit
   end
 
   def show(path, ref)
-    cmds << ["show", path, ref]
+    git("show", path, ref)
+  end
+
+  def ls_tree(path, ref)
+    git("ls-tree", path, ref)
+  end
+
+  def git(*args)
+    cmds << args
     deferred = When::Deferred.new
     deferreds << deferred.resolver
     deferred.promise
@@ -67,4 +75,35 @@ describe Dolt::Git::Repository do
       @git.last_resolver.resolve("class Repository;end")
     end
   end
+
+  describe "#tree" do
+    it "uses git ls-tree to list tree" do
+      repo = Dolt::Git::Repository.new("gitorious", @git)
+      repo.tree("app/models", "master")
+
+      assert_equal ["ls-tree", "app/models", "master"], @git.last_command
+    end
+
+    it "defaults to listing tree at HEAD" do
+      repo = Dolt::Git::Repository.new("gitorious", @git)
+      repo.tree("app/models")
+
+      assert_equal ["ls-tree", "app/models", "HEAD"], @git.last_command
+    end
+
+    it "invokes callback with tree object" do
+      repo = Dolt::Git::Repository.new("gitorious", @git)
+      d = repo.tree("app/models")
+
+      d.callback do |tree|
+        assert_equal 3, tree.entries.length
+      end
+
+      @git.last_resolver.resolve(<<-GIT)
+100644 blob e90021f89616ddf86855d05337c188408d3b417e    .gitmodules
+100644 blob c80ee3697054566d1a4247d80be78ec3ddfde295    Gemfile
+100644 blob 0053b3c95b0d9faa4916f7cd5e559c2b0f138027    Gemfile.lock
+      GIT
+    end
+  end
 end

data/test/dolt/git/shell_test.rb

@@ -24,55 +24,89 @@ describe Dolt::Git::Shell do
   include EM::MiniTest::Spec
   include Dolt::StdioStub
 
-  it "assumes git dir in work tree" do
-    expected_cmd = ["git --git-dir /somewhere/.git ",
-                    "--work-tree /somewhere log"].join
-    Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
-    git = Dolt::Git::Shell.new("/somewhere")
-    git.git("log")
-  end
+  describe "#git" do
+    it "assumes git dir in work tree" do
+      expected_cmd = ["git --git-dir /somewhere/.git ",
+                      "--work-tree /somewhere log"].join
+      Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.git("log")
+    end
 
-  it "uses provided git dir" do
-    expected_cmd = ["git --git-dir /somewhere/.git ",
-                    "--work-tree /elsewhere log"].join
-    Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
-    git = Dolt::Git::Shell.new("/elsewhere", "/somewhere/.git")
-    git.git("log")
-  end
+    it "uses provided git dir" do
+      expected_cmd = ["git --git-dir /somewhere/.git ",
+                      "--work-tree /elsewhere log"].join
+      Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
+      git = Dolt::Git::Shell.new("/elsewhere", "/somewhere/.git")
+      git.git("log")
+    end
 
-  it "returns deferrable" do
-    silence_stderr do
-      git = Dolt::Git::Shell.new("/somwhere")
-      result = git.git("log")
+    it "returns deferrable" do
+      silence_stderr do
+        git = Dolt::Git::Shell.new("/somwhere")
+        result = git.git("log")
 
-      assert result.respond_to?(:callback)
-      assert result.respond_to?(:errback)
+        assert result.respond_to?(:callback)
+        assert result.respond_to?(:errback)
+      end
     end
-  end
 
-  it "joins arguments with spaces" do
-    expected_cmd = ["git --git-dir /somewhere/.git ",
-                    "--work-tree /somewhere push origin master"].join
-    Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
-    git = Dolt::Git::Shell.new("/somewhere")
-    git.git("push", "origin", "master")
+    it "joins arguments with spaces" do
+      expected_cmd = ["git --git-dir /somewhere/.git ",
+                      "--work-tree /somewhere push origin master"].join
+      Dolt::DeferrableChildProcess.expects(:open).with(expected_cmd)
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.git("push", "origin", "master")
+    end
+
+    it "calls errback when git operation fails" do
+      silence_stderr do
+        git = Dolt::Git::Shell.new("/somewhere")
+        result = git.git("push", "origin", "master")
+        result.errback do |status|
+          refute status.nil?
+          done!
+        end
+        wait!
+      end
+    end
   end
 
-  it "calls errback when git operation fails" do
-    silence_stderr do
+  describe "#show" do
+    it "shows a file" do
       git = Dolt::Git::Shell.new("/somewhere")
-      result = git.git("push", "origin", "master")
-      result.errback do |status|
-        refute status.nil?
-        done!
-      end
-      wait!
+      git.expects(:git).with("show", "master:app/models/repository.rb")
+      result = git.show("app/models/repository.rb", "master")
     end
   end
 
-  it "shows a file" do
-    git = Dolt::Git::Shell.new("/somewhere")
-    git.expects(:git).with("show", "master:app/models/repository.rb")
-    result = git.show("app/models/repository.rb", "master")
+  describe "#ls_tree" do
+    it "lists tree root" do
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.expects(:git).with("ls-tree", "master", "./")
+
+      result = git.ls_tree("", "master")
+    end
+
+    it "lists tree root when starting with slash" do
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.expects(:git).with("ls-tree", "master", "./")
+
+      result = git.ls_tree("/", "master")
+    end
+
+    it "lists path with trailing slash" do
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.expects(:git).with("ls-tree", "master", "./app/models/")
+
+      result = git.ls_tree("app/models", "master")
+    end
+
+    it "lists path at given ref" do
+      git = Dolt::Git::Shell.new("/somewhere")
+      git.expects(:git).with("ls-tree", "v2.0.0", "./app/models/")
+
+      result = git.ls_tree("app/models/", "v2.0.0")
+    end
   end
 end

data/test/dolt/git/tree_test.rb

@@ -0,0 +1,120 @@
+# 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/git/tree"
+
+describe Dolt::Git::Tree do
+  describe "parsing root tree" do
+    before do
+      lines = <<-GIT
+100644 blob e90021f89616ddf86855d05337c188408d3b417e    .gitmodules
+100644 blob c80ee3697054566d1a4247d80be78ec3ddfde295    Gemfile
+100644 blob 0053b3c95b0d9faa4916f7cd5e559c2b0f138027    Gemfile.lock
+100644 blob 2ad22ff4b188c256d8ac97ded87c1c6ef6e96e43    Rakefile
+100644 blob c8d1d197abfcd0f96c47583ec5f4328565cba433    Readme.md
+040000 tree 18052467e73a1b7fb2613dc7b36baa554fab024b    bin
+100644 blob e83bb675977e7277698320cdd9c595c5698e5aa5    dolt.gemspec
+040000 tree 4b051dd46c3ba70fbfd6a2484ec00121a70bee3a    lib
+040000 tree 86b096dc99b2cba28daa7676ed0dd38f709527b2    test
+040000 tree d74d6bcb50cc5de9eb8fe019d7798b04d3a427e9    vendor
+040000 tree be8fb09b735ac23265db2bec7c23e022a99ee730    views
+      GIT
+
+      @tree = Dolt::Git::Tree.parse("", lines)
+    end
+
+    it "has path" do
+      assert_equal "./", @tree.path
+    end
+
+    it "extracts each line as an entry" do
+      assert_equal 11, @tree.entries.length
+    end
+
+    it "extracts file entry objects" do
+      gemfile = @tree.entries[6]
+
+      assert gemfile.file?
+      assert !gemfile.dir?
+      assert_equal "Gemfile", gemfile.path
+      assert_equal "Gemfile", gemfile.full_path
+      assert_equal "100644", gemfile.mode
+      assert_equal "c80ee3697054566d1a4247d80be78ec3ddfde295", gemfile.sha
+    end
+
+    it "extracts directory entry objects" do
+      bin = @tree.entries[0]
+
+      assert !bin.file?
+      assert bin.dir?
+      assert_equal "bin", bin.path
+      assert_equal "040000", bin.mode
+      assert_equal "18052467e73a1b7fb2613dc7b36baa554fab024b", bin.sha
+    end
+  end
+
+  describe "parsing nested tree" do
+    before do
+      lines = <<-GIT
+040000 tree c1d92125977841b672a10c96c6800e1b360a4e62    lib/dolt/async
+100644 blob 6da3991090ba2df53eabe05bf4330aadf370a43a    lib/dolt/disk_repo_resolver.rb
+040000 tree 0142bdb42936094cdd92aa188d3193be85f7a6c1    lib/dolt/git
+100644 blob 2b8674702e62aaa5607317ed83085e74a62b9781    lib/dolt/repo_actions.rb
+040000 tree d93b4afc62ad460387cf5d91d98d1ad306219419    lib/dolt/sinatra
+100644 blob 2a7e89f4b940e23a3d921199d9000e93da299872    lib/dolt/template_renderer.rb
+100644 blob dfe78a965009e27d9cce7c9733787acb564b6630    lib/dolt/version.rb
+100644 blob 685369dd2a66f0313b232ee898f8bbdafec6862d    lib/dolt/view.rb
+040000 tree 78347f337aaa613eb0a1c27ae7f89e39a22dcd6f    lib/dolt/view
+      GIT
+
+      @tree = Dolt::Git::Tree.parse("lib/dolt", lines)
+    end
+
+    it "does not include ./ in path" do
+      assert_equal "lib/dolt", @tree.path
+    end
+
+    it "strips root path from entries" do
+      assert_equal "disk_repo_resolver.rb", @tree.entries[4].path
+    end
+
+    it "groups tree by type, dirs first" do
+      assert @tree.entries[0].dir?
+      assert @tree.entries[1].dir?
+      assert @tree.entries[2].dir?
+      assert @tree.entries[3].dir?
+      assert @tree.entries[4].file?
+      assert @tree.entries[5].file?
+      assert @tree.entries[6].file?
+      assert @tree.entries[7].file?
+      assert @tree.entries[8].file?
+    end
+
+    it "sorts tree entries alphabetically" do
+      assert_equal "async", @tree.entries[0].path
+      assert_equal "git", @tree.entries[1].path
+      assert_equal "sinatra", @tree.entries[2].path
+      assert_equal "view", @tree.entries[3].path
+      assert_equal "disk_repo_resolver.rb", @tree.entries[4].path
+      assert_equal "repo_actions.rb", @tree.entries[5].path
+      assert_equal "template_renderer.rb", @tree.entries[6].path
+      assert_equal "version.rb", @tree.entries[7].path
+      assert_equal "view.rb", @tree.entries[8].path
+    end
+  end
+end

data/test/dolt/repo_actions_test.rb

@@ -28,7 +28,12 @@ class Repository
     @deferred.promise
   end
 
-  def yield_blob(blob)
+  def tree(path, ref)
+    @deferred = When::Deferred.new
+    @deferred.promise
+  end
+
+  def resolve_promise(blob)
     @deferred.resolve(blob)
   end
 end
@@ -52,22 +57,46 @@ describe Dolt::RepoActions do
 
   describe "#blob" do
     it "resolves repository" do
-      @actions.blob("gitorious", "master", "app")
+      @actions.blob("gitorious", "app", "master")
 
       assert_equal ["gitorious"], @resolver.resolved.map(&:name)
     end
 
-    it "yields blob, repo and ref to block" do
+    it "yields blob, repo, ref and base_tree_url to block" do
       data = nil
-      @actions.blob("gitorious", "babd120", "app") do |status, d|
+      @actions.blob("gitorious", "app", "babd120") do |status, d|
         data = d
       end
 
       repo = @resolver.resolved.last
-      repo.yield_blob "Blob"
+      repo.resolve_promise "Blob"
 
-      expected = { :blob => "Blob", :repository => repo, :ref =>  "babd120" }
-      assert_equal expected, data
+      assert_equal({
+        :blob => "Blob",
+        :repository => repo,
+        :ref =>  "babd120"
+      }, data)
     end
   end
+
+  describe "#tree" do
+    it "resolves repository" do
+      @actions.tree("gitorious", "app", "master")
+
+      assert_equal ["gitorious"], @resolver.resolved.map(&:name)
+    end
+
+    it "yields tree, repo and ref to block" do
+      data = nil
+      @actions.tree("gitorious", "app", "babd120") do |status, d|
+        data = d
+      end
+
+      repo = @resolver.resolved.last
+      repo.resolve_promise "Tree"
+
+      expected = { :tree => "Tree", :repository => repo, :ref =>  "babd120" }
+      assert_equal expected, data
+    end
+ end
 end

data/test/dolt/template_renderer_test.rb

@@ -77,4 +77,12 @@ 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 %>")
+
+    assert_equal "THING", renderer.render(:file)
+  end
 end

data/test/dolt/views/blob_test.rb

@@ -28,6 +28,9 @@ describe "blob template" do
   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)
     renderer.render(:blob, {
@@ -38,14 +41,14 @@ describe "blob template" do
   end
 
   it "renders blob without errors" do
-    blob = Dolt::Blob.new("file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("file.txt", "Something something")
     markup = render(blob)
 
     assert_match /Something something/, markup
   end
 
   it "renders blob with line numbers" do
-    blob = Dolt::Blob.new("file.txt", "One\nTwo\nThree")
+    blob = Dolt::Git::Blob.new("file.txt", "One\nTwo\nThree")
     markup = render(blob)
 
     assert_match /<li.*One.*<\/li>/, markup
@@ -54,21 +57,21 @@ describe "blob template" do
   end
 
   it "renders blob with layout" do
-    blob = Dolt::Blob.new("file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("file.txt", "Something something")
     markup = render(blob, :layout => "layout")
 
     assert_match /Something something/, markup
   end
 
   it "renders repo title in page" do
-    blob = Dolt::Blob.new("file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("file.txt", "Something something")
     markup = render(blob, :layout => "layout")
 
     assert_match @repo.name, markup
   end
 
   it "renders links to other views" do
-    blob = Dolt::Blob.new("file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("file.txt", "Something something")
     markup = render(blob)
 
     assert_match "/the-dolt/blame/master:file.txt", markup
@@ -76,8 +79,17 @@ describe "blob template" do
     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::Blob.new("file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("file.txt", "Something something")
     markup = render(blob, :ref => "123bc21")
 
     assert_match "/the-dolt/blame/123bc21:file.txt", markup
@@ -86,7 +98,7 @@ describe "blob template" do
   end
 
   it "renders the path clickable" do
-    blob = Dolt::Blob.new("some/deeply/nested/file.txt", "Something something")
+    blob = Dolt::Git::Blob.new("some/deeply/nested/file.txt", "Something something")
     markup = render(blob)
 
     assert_match 'href="/the-dolt/tree/master:some"', markup

data/views/blob.erb

@@ -19,6 +19,7 @@
 %>
 <%
   @title = "#{blob.path} in #{repository.name}:master"
+  if !defined?(multi_repo_mode); multi_repo_mode = false; end
 %>
 <div class="gts-file">
   <%#
@@ -34,10 +35,10 @@
   %>
   <ul class="pull-right gts-blob-view">
     <li class="active">Blob content</li>
-    <li><a href="/<%= repository.name %>/blame/<%= ref %>:<%= blob.path %>">Blame</a></li>
-    <li><a href="/<%= repository.name %>/history/<%= ref %>:<%= blob.path %>">History</a></li>
-    <li><a href="/<%= repository.name %>/raw/<%= ref %>:<%= blob.path %>">Raw blob</a></li>
+    <li><a href="<%= blame_url(repository, blob, ref, multi_repo_mode) %>">Blame</a></li>
+    <li><a href="<%= history_url(repository, blob, ref, multi_repo_mode) %>">History</a></li>
+    <li><a href="<%= raw_url(repository, blob, ref, multi_repo_mode) %>">Raw blob</a></li>
   </ul>
-  <%= breadcrumb(repository, ref, blob.path) %>
+  <%= breadcrumb(repository, blob.path, ref, :multi_repo_mode => multi_repo_mode) %>
   <%= highlight_lines(blob.path, blob.raw) %>
 </div>

data/views/tree.erb

@@ -0,0 +1,44 @@
+<%#
+   # 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/>.
+   #++
+   %>
+<% @title = "#{tree.path} in #{repository.name}:#{ref}" %>
+<table class="table table-striped gts-tree-explorer">
+  <thead>
+    <tr>
+      <th>File</th>
+      <th>Changed</th>
+      <th colspan="2">Last commit</th>
+    </tr>
+  </thead>
+  <tbody>
+    <% tree.entries.each do |entry| %>
+      <tr>
+        <td class="gts-name">
+          <a href="<%= tree_url(repository, entry, ref, defined?(multi_repo_mode) && multi_repo_mode) %>">
+            <i class="icon <%= entry.file? ? "icon-file" : "icon-folder-close" %>"></i>
+            <%= entry.path %>
+          </a>
+        </td>
+        <td></td>
+        <td class="gts-sha"></td>
+        <td></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dolt
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Christian Johansen
@@ -190,6 +190,7 @@ files:
 - ./lib/dolt/git/blob.rb
 - ./lib/dolt/git/repository.rb
 - ./lib/dolt/git/shell.rb
+- ./lib/dolt/git/tree.rb
 - ./lib/dolt/repo_actions.rb
 - ./lib/dolt/sinatra/actions.rb
 - ./lib/dolt/sinatra/base.rb
@@ -203,6 +204,7 @@ files:
 - ./test/dolt/git/blob_test.rb
 - ./test/dolt/git/repository_test.rb
 - ./test/dolt/git/shell_test.rb
+- ./test/dolt/git/tree_test.rb
 - ./test/dolt/repo_actions_test.rb
 - ./test/dolt/sinatra/actions_test.rb
 - ./test/dolt/template_renderer_test.rb
@@ -211,6 +213,7 @@ files:
 - ./test/test_helper.rb
 - ./views/blob.erb
 - ./views/layout.erb
+- ./views/tree.erb
 - vendor/ui/bootstrap/css/bootstrap-responsive.min.css
 - vendor/ui/bootstrap/css/bootstrap.min.css
 - vendor/ui/bootstrap/img/glyphicons-halflings-white.png