libdolt 0.26.0 → 0.27.0

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - rbx-19mode
-  - ruby-head
   - 1.8.7
   - ree
+before_install:
+  - sudo apt-get install -y libicu-dev

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    libdolt (0.26.0)
+    libdolt (0.27.0)
       htmlentities (~> 4.3)
       json (~> 1.7)
       makeup (~> 0.4)

data/Readme.md

@@ -1,102 +1,211 @@
-# Dolt - The Git project browser
+# libdolt - Git repository browser internals
 
 <a href="http://travis-ci.org/cjohansen/libdolt" class="travis">
   <img src="https://secure.travis-ci.org/cjohansen/libdolt.png">
 </a>
 
-Dolt is a stand-alone Git repository browser. It can be used to explore repos in
-your browser of choice and features syntax highlighting with
-[Pygments](http://pygments.org/),
-[Markdown](http://daringfireball.net/projects/markdown/)/[org-mode](http://orgmode.org/)/[+++](https://github.com/github/markup/)
-rendering, commit log and blame.
+`libdolt` is all the reusable internal workings of the
+[Dolt repository browser](https://gitorious.org/gitorious/dolt). It provides all
+the mechanics for retrieving the data you need display Git trees, blobs, blame
+and more, and also includes tools to render them in a web context.
 
-Dolt is also a library, designed to render Git trees, blobs, commit log and
-blame. It can render said views with or without a layout, or you can provide
-your own templates (through [Tilt](https://github.com/rtomayko/tilt/)). You can
-also provide your own rendering implementation to render other formats than
-templates outputting HTML.
+`libdolt` does not depend on Sinatra, or any other web context, so it can easily
+be embedded in other frameworks/apps. Most notably, `libdolt` is used as the
+repository browser in [Gitorious 3](https://gitorious.org/gitorious/mainline),
+and as a stand-alone repository browser in [Dolt](https://gitorious.org/gitorious/dolt).
 
-Dolt is the implementation of the next generation repo browser to be used in the
-[Gitorious](http://gitorious.org) software.
+## Installing libdolt
 
-## Installing Dolt
-
-To install `dolt` you need Ruby, RubyGems and Python development files. The
-Python development files are required to support Pygments syntax highlighting.
-
-Note: Dolt uses [libgit2](http://libgit2.github.com) and its Ruby bindings,
-[Rugged](http://github.com/libgit2/rugged) for Git access where
-feasible. Currently, ``Dolt`` relies on a version of `Rugged` that is not
-yet released, so you have to build it yourself.
-[See em-rugged instructions](http://github.com/cjohansen/em-rugged).
+libdolt depends on two system packages to do its job.
 
 ### Systems using apt (Debian/Ubuntu, others)
 
-    # 1) Install Ruby (skip if you already have Ruby installed)
-    sudo apt-get install ruby
+    # 1) Install Python development files
+    sudo apt-get install -y python-dev libicu-dev
 
-    # 2) Install Python development files
-    sudo apt-get install python-dev
-
-    # 3) Install dolt. This may or may not require the use of sudo, depending on
-    #    how you installed Ruby. This step assumes that you already built and
-    #    installed em-rugged as explained above.
-    sudo gem install dolt
+    # 2) Install dolt. This may or may not require the use of sudo, depending on
+    #    how you installed Ruby.
+    gem install libdolt
 
 ### Systems using yum (Fedora/CentOS/RedHat, others)
 
-    # 1) Install Ruby (skip if you already have Ruby installed)
-    sudo yum install ruby
-
-    # 2) Install Python development files
-    sudo yum install python-devel
+    # 1) Install Python development files
+    sudo yum install -y python-devel libicu-devel
 
     # 3) Install dolt. This may or may not require the use of sudo, depending on
-    #    how you installed Ruby. This step assumes that you already built and
-    #    installed em-rugged as explained above.
-    sudo gem install dolt
-
-# The Dolt CLI
-
-The `dolt` library installs a CLI that can be used to quickly browse either a
-single (typically the current) repository, or multiple repositories.
-
-## Browsing a single repository
-
-In a git repository, issue the following command:
+    #    how you installed Ruby.
+    gem install dolt
+
+## API
+
+`libdolt` provides two main abstractions you may be interested in:
+
+* `Dolt::RepositoryLookup` provides an API that will fetch various bits of
+  information from your git repository, and returns a hash of data. This hash
+  can typically be used for rendering in a template of some sort.
+* `Dolt::ControllerActions` provides a web front-end to the repository lookup.
+  It will use the lookup class to fetch the information it needs, and then it
+  will render them using [Tiltout](https://gitorious.org/gitorious/tiltout). If
+  you're looking to make a web-based repository browser, you can use this class
+  in a Sinatra, Rack or Rails application, provide you own templates etc.
+
+## Repository lookups
+
+The `Dolt::RepositoryLookup` class provides many methods that use
+[libgit2/Rugged](https://github.com/libgit2/rugged) in conjunction with the
+classes found in `lib/libdolt/git` to fetch, consolidate and prepare Git
+repository data in a display-friendly way. All methods return a hash.
+
+The repository lookup class depends on a "repository resolver". This is an
+object that can take a string from the URL, such as `"gitorious/mainline"` and
+return a usable repository object. The repository object is expected to conform
+to the `Dolt::Git::Repository` interface. Typically you will want to instantiate
+this object, but you can in theory provide your own implementation, so long as
+you maintain the interface.
+
+Repository resolvers are quite simple animals. Here's an example of how to make
+Dolt work with Gitorious' Repository model objects:
+
+```rb
+module Gitorious
+  module Dolt
+    class RepositoryResolver
+      # How you initialize your objects is up to you - Dolt doesn't care, it
+      # only ever sees the instance, not the class itself.
+      def initialize(scope = ::Repository)
+        @scope = scope
+      end
+
+      def resolve(repo)
+        repository = @scope.find_by_path(repo)
+        raise ActiveRecord::RecordNotFound.new if repository.nil?
+        Gitorious::Dolt::Repository.new(repository)
+      end
+    end
+  end
+end
+```
+
+### Common data
+
+All actions return a hash that include these keys:
+
+* `path` - The repository-relative path
+* `ref` - The ref or object id
+
+### Example: Looking up a tree
+
+```rb
+resolver = Gitorious::Dolt::RepositoryResolver.new
+lookup = Dolt::RepositoryLookup.new(resolver)
+
+data = lookup.tree("gitorious/mainline", "master", "")
+#=> {
+#  :path => "",
+#  :ref => "master",
+#  :tree => #<Rugged::Tree:16209820 {oid: 89cd7e9d4564928de6b803b36c6e3d081c8d9ca1}>
+#     <"README.org" b40c249db94476cac7fa91a9d6491c0faf21ec21>
+#     <"lib" 264c348a80906538018616fa16fc35d04bdf38b0>,
+#  :readme => { :blob => #<Rugged::Blob:0x00000002111460>, :path => "README.org" }
+# }
+```
+
+Note that the `tree` lookup will include a readme blob if one is available, and
+Dolt is able to render it.
+
+## Controller actions
+
+The controller actions that ship with libdolt are web framework agnostic. They
+return arrays that can be passed directly to Rack, or can be picked apart for
+further processing. The controller actions can be configured to redirect any
+request for symbolic refs (e.g. a request for something on "master" will
+redirect to the current tip of that branch), and it provides error handling,
+renders blobs with syntax highlighting and more.
+
+The controller actions have three dependencies: a router, a repository lookup
+instance (see above) and a renderer.
+
+The router is expected to respond to these messages:
+
+* `tree_url(repo, ref, path)`
+* `blob_url(repo, ref, path)`
+* `tree_entry_url(repo, ref, path)`
+* `blame_url(repo, ref, path)`
+* `history_url(repo, ref, path)`
+* `tree_history_url(repo, ref, path)`
+* `raw_url(repo, ref, path)`
+
+The renderer can be anything that understands this message:
+
+```rb
+renderer.render(template, data, template_options)
+
+# e.g.
+renderer.render("tree", {
+  :ref => "master",
+  :path => lib",
+  :tree => tree
+}, { :layout => "dark_skin" })
+```
+
+[Tiltout](https://gitorious.org/gitorious/tiltout) is well suited for the task.
+To just use the built-in templates in libdolt:
+
+```rb
+renderer = Tiltout.new(Dolt.template_dir, { :layout => "layout" })
+renderer.helper(Dolt::View::Object)
+renderer.helper(Dolt::View::Urls)
+renderer.helper(Dolt::View::Blob)
+renderer.helper(Dolt::View::Blame)
+renderer.helper(Dolt::View::Breadcrumb)
+renderer.helper(Dolt::View::Tree)
+renderer.helper(Dolt::View::Commit)
+renderer.helper(Dolt::View::Gravatar)
+renderer.helper(Dolt::View::TabWidth)
+renderer.helper(Dolt::View::BinaryBlobEmbedder)
+renderer.helper(:tab_width => options[:tab_width], :maxdepth => 3)
+
+actions = Dolt::ControllerActions.new(some_router, lookup, renderer)
+response = actions.blob("gitorious/libdolt", "master", "Readme.md")
+
+#=> [200, {
+  "Content-Type" => "text/html; charset=utf-8",
+  "X-UA-Compatible" => "IE=edge"
+}, [html...]]
+```
+
+The controller actions also accept a last argument, which is a hash of
+additional data to expose to the templates. This is useful if you are using
+a custom layout and/or templates.
 
-    $ dolt .
-
-Then open a browser at [http://localhost:3000](http://localhost:3000). You will
-be redirected to the root tree, and can browse the repository. To view trees and
-blobs at specific refs, use the URL. A branch/tag selector will be added later.
-
-## Browsing multiple repositories
-
-The idea is that eventually, `dolt` should be able to serve up all Git
-repositories managed by your Gitorious server. It does not yet do that, because
-there currently is no "repository resolver" that understands the hashed paths
-Gitorious uses.
+## Markup rendering
 
-Meanwhile, if you have a directory that contains multiple git repositories, you
-can browse all of them through the same process by doing:
+Dolt uses the [``GitHub::Markup``](https://github.com/github/markup/) library
+(through [Makeup](https://gitorious.org/gitorious/makeup)) to render certain
+markup formats as HTML. Dolt does not have a hard dependency on any of the
+required gems to actually render markups, so see the
+[``GitHub::Markup`` docs](https://github.com/github/markup/) for information on
+what and how to install support for various languages.
 
-    $ dolt /path/to/repos
+Various rendering techniques are implemented as modules that can be included in
+you Tiltout views. Here's an excerpt from Dolt's `bin/dolt` script (which runs a
+standalone repository browser locally on your box):
 
-Now [http://localhost:3000/repo](http://localhost:3000/repo) will allow you to
-browse the `/path/repos/repo` repository. As `dolt` matures, there will be a
-listing of all repositories and more.
+```rb
+# Attempt to syntax highlight every blob
+# renderer.helper(Dolt::View::SyntaxHighlight)
 
-## Markup rendering
+# Attempt to render every blob as markup
+# renderer.helper(Dolt::View::Markup)
 
-Dolt uses the [``GitHub::Markup``](https://github.com/github/markup/) library to
-render certain markup formats as HTML. Dolt does not have a hard dependency on
-any of the required gems to actually render markups, so see the
-[``GitHub::Markup`` docs](https://github.com/github/markup/) for information on
-what and how to install support for various languages.
+# Render supported formats as markup, syntax highlight the rest
+# (if attempting to render some format as markup crashes, it will
+# fall back to syntax highlighting)
+renderer.helper(Dolt::View::SmartBlobRenderer)
+```
 
 # License
 
-Dolt is free software licensed under the
+libdolt is free software licensed under the
 [GNU Affero General Public License (AGPL)](http://www.gnu.org/licenses/agpl-3.0.html).
-Dolt is developed as part of the Gitorious project.
+libdolt is developed as part of the Gitorious project.

data/lib/libdolt/controller_actions.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+#--
+#   Copyright (C) 2012-2013 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 "json"
+require "time"
+require "cgi"
+
+module Dolt
+  class ControllerActions
+    def initialize(router, lookup, renderer)
+      @router = router
+      @lookup = lookup
+      @renderer = renderer
+    end
+
+    def redirect(url, status = 302)
+      body = "You are being <a href=\"#{url}\">redirected to #{url}</a>"
+      [status, { "Location" => url }, [body]]
+    end
+
+    def render_error(error, repo, ref, data = {})
+      $stderr.puts(error.message)
+      $stderr.puts(error.backtrace)
+
+      if error.class.to_s == "Rugged::ReferenceError" && ref == "HEAD"
+        return [200, headers, [renderer.render("empty", {
+                :repository => repo,
+                :ref => ref
+              }.merge(data))]]
+      end
+
+      [response, headers, [renderer.render(response.to_s.to_sym, {
+              :error => error,
+              :repository_slug => repo,
+              :ref => ref
+            }.merge(data))]]
+    rescue Exception => err
+      err_backtrace = err.backtrace.map { |s| "<li>#{s}</li>" }
+      error_backtrace = error.backtrace.map { |s| "<li>#{s}</li>" }
+
+      [500, headers, [<<-HTML]]
+        <h1>Fatal Dolt Error</h1>
+        <p>
+          Dolt encountered an exception, and additionally
+          triggered another exception trying to render the error.
+        </p>
+        <p>Tried to render the #{template} template with the following data:</p>
+        <dl>
+          <dt>Repository</dt>
+          <dd>#{repo}</dd>
+          <dt>Ref</dt>
+          <dd>#{ref}</dd>
+        </dl>
+        <h2>Error: #{err.class} #{err.message}</h2>
+        <ul>#{err_backtrace.join()}</ul>
+        <h2>Original error: #{error.class} #{error.message}</h2>
+        <ul>#{error_backtrace.join()}</ul>
+        HTML
+    end
+
+    def raw(repo, ref, path, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.raw_url(repo, oid, path), 307)
+      end
+
+      blob(repo, ref, path, custom_data, {
+          :template => :raw,
+          :content_type => "text/plain",
+          :template_options => { :layout => nil }
+        })
+    end
+
+    def blob(repo, ref, path, custom_data = {}, options = { :template => :blob })
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.blob_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.blob(repo, u(ref), path))
+      blob = data[:blob]
+      return redirect(router.tree_url(repo, ref, path)) if blob.class.to_s !~ /\bBlob/
+
+      tpl_options = options[:template_options] || {}
+      [200, headers(options.merge(:ref => ref)), [
+          renderer.render(options[:template], data, tpl_options)
+        ]]
+    end
+
+    def tree(repo, ref, path, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.tree_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.tree(repo, u(ref), path))
+      tree = data[:tree]
+      return redirect(router.blob_url(repo, ref, path)) if tree.class.to_s !~ /\bTree/
+      [200, headers(:ref => ref), [renderer.render(:tree, data)]]
+    end
+
+    def tree_entry(repo, ref, path, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.tree_entry_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.tree_entry(repo, u(ref), path))
+      body = renderer.render(data.key?(:tree) ? :tree : :blob, data)
+      [200, headers(:ref => ref), [body]]
+    end
+
+    def blame(repo, ref, path, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.blame_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.blame(repo, u(ref), path))
+      [200, headers(:ref => ref), [renderer.render(:blame, data)]]
+    end
+
+    def history(repo, ref, path, count, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.history_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.history(repo, u(ref), path, count))
+      [200, headers(:ref => ref), [renderer.render(:commits, data)]]
+    end
+
+    def refs(repo, custom_data = {})
+      data = (custom_data || {}).merge(lookup.refs(repo))
+      [200, headers(:content_type => "application/json"), [
+          renderer.render(:refs, data, :layout => nil)
+        ]]
+    end
+
+    def tree_history(repo, ref, path, count = 1, custom_data = {})
+      if oid = lookup_ref_oid(repo, ref)
+        return redirect(router.tree_history_url(repo, oid, path), 307)
+      end
+
+      data = (custom_data || {}).merge(lookup.tree_history(repo, u(ref), path, count))
+      [200, headers(:content_type => "application/json", :ref => ref), [
+          renderer.render(:tree_history, data, :layout => nil)
+        ]]
+    end
+
+    def resolve_repository(repo)
+      @cache ||= {}
+      @cache[repo] ||= lookup.resolve_repository(repo)
+    end
+
+    def lookup_ref_oid(repo, ref)
+      return if !router.respond_to?(:redirect_refs?) || !router.redirect_refs? || ref.length == 40
+      lookup.rev_parse_oid(repo, ref)
+    end
+
+    private
+    attr_reader :router, :lookup, :renderer
+
+    def u(str)
+      # Temporarily swap the + out with a magic byte, so
+      # filenames/branches with +'s won't get unescaped to a space
+      CGI.unescape(str.gsub("+", "\001")).gsub("\001", '+')
+    end
+
+    def headers(options = {})
+      default_ct = "text/html; charset=utf-8"
+      year = 60*60*24*365
+
+      {
+        "Content-Type" => options[:content_type] || default_ct,
+        "X-UA-Compatible" => "IE=edge"
+      }.merge(!options[:ref] || options[:ref].length != 40 ? {} : {
+          "Cache-Control" => "max-age=315360000, public",
+          "Expires" => (Time.now + year).httpdate
+        })
+    end
+  end
+end

data/lib/libdolt/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Dolt
-  VERSION = "0.26.0"
+  VERSION = "0.27.0"
 end

data/lib/libdolt.rb

@@ -17,8 +17,8 @@
 #++
 require "libdolt/version"
 require "libdolt/disk_repo_resolver"
-require "libdolt/gitorious_repo_resolver"
 require "libdolt/repository_lookup"
+require "libdolt/controller_actions"
 require "libdolt/view"
 
 module Dolt

data/test/libdolt/controller_actions_test.rb

@@ -0,0 +1,475 @@
+# encoding: utf-8
+#--
+#   Copyright (C) 2012-2013 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 "libdolt/controller_actions"
+
+describe Dolt::ControllerActions do
+  describe "#blob" do
+    it "delegates to lookup" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new)
+
+      dolt.blob("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "gitorious", lookup.repo
+      assert_equal "master", lookup.ref
+      assert_equal "app/models/repository.rb", lookup.path
+    end
+
+    it "renders the blob template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.blob("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "blob:Blob", body(response)
+    end
+
+    it "renders the blob template with custom data" do
+      renderer = Test::Renderer.new("Blob")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Blob.new), renderer)
+
+      dolt.blob("gitorious", "master", "app/models/repository.rb", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "redirects tree views to tree action" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.blob("gitorious", "master", "app/models")
+
+      assert_equal 302, status(response)
+      assert_equal "/gitorious/tree/master:app/models", header(response, "Location")
+      assert_match "You are being ", body(response)
+      assert_match "redirected", body(response)
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Blob"))
+
+      dolt.blob("gitorious", "issue-%23221", "app/my documents")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "does not redirect ref to oid by default" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.blob("gitorious", "master", "lib/gitorious.rb")
+
+      location = header(response, "Location")
+      refute_equal 302, status(response)
+      refute_equal 307, status(response)
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.blob("gitorious", "master", "lib/gitorious.rb")
+
+      location = header(response, "Location")
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/blob/#{'a' * 40}:lib/gitorious.rb", location
+      assert_match "You are being", body(response)
+    end
+  end
+
+  describe "#tree" do
+    it "delegates to actions" do
+      lookup = Test::Lookup.new(Stub::Tree.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new)
+
+      dolt.tree("gitorious", "master", "app/models")
+
+      assert_equal "gitorious", lookup.repo
+      assert_equal "master", lookup.ref
+      assert_equal "app/models", lookup.path
+    end
+
+    it "renders the tree template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "master", "app/models")
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "tree:Tree", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Tree")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Tree.new), renderer)
+
+      dolt.tree("gitorious", "master", "app/models", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "redirects blob views to blob action" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "master", "app/models/repository.rb")
+
+      location = header(response, "Location")
+      assert_equal 302, status(response)
+      assert_equal "/gitorious/blob/master:app/models/repository.rb", location
+      assert_match "You are being", body(response)
+    end
+
+    it "sets X-UA-Compatible header" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "master", "app/models")
+
+      assert_equal "IE=edge", header(response, "X-UA-Compatible")
+    end
+
+    it "does not set cache-control header for head ref" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "master", "app/models")
+
+      assert_nil header(response, "Cache-Control")
+    end
+
+    it "sets cache headers for full oid ref" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "a" * 40, "app/models")
+
+      assert_equal "max-age=315360000, public", header(response, "Cache-Control")
+      refute_nil header(response, "Expires")
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Tree.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Tree"))
+
+      dolt.tree("gitorious", "issue-%23221", "app")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree("gitorious", "master", "lib")
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/tree/#{'a' * 40}:lib", header(response, "Location")
+    end
+  end
+
+  describe "#tree_entry" do
+    it "renders trees with the tree template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree_entry("gitorious", "master", "app/models")
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "tree:Tree", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Tree")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Tree.new), renderer)
+
+      dolt.tree_entry("gitorious", "master", "app/models", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "renders trees with the tree template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.tree_entry("gitorious", "master", "app/models")
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "blob:Blob", body(response)
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Tree.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Tree"))
+
+      dolt.tree_entry("gitorious", "issue-%23221", "app")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree_entry("gitorious", "master", "lib")
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/source/#{'a' * 40}:lib", header(response, "Location")
+    end
+  end
+
+  describe "#raw" do
+    it "delegates to lookup" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new)
+
+      dolt.raw("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "gitorious", lookup.repo
+      assert_equal "master", lookup.ref
+      assert_equal "app/models/repository.rb", lookup.path
+    end
+
+    it "renders the raw template as text" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Text"))
+
+      response = dolt.raw("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "text/plain", header(response, "Content-Type")
+      assert_equal "raw:Text", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Text")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Blob.new), renderer)
+
+      dolt.raw("gitorious", "master", "app/models/repository.rb", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "redirects tree views to tree action" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.raw("gitorious", "master", "app/models")
+
+      location = header(response, "Location")
+      assert_equal 302, status(response)
+      assert_equal "/gitorious/tree/master:app/models", location
+      assert_match "You are being", body(response)
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Blob"))
+
+      dolt.raw("gitorious", "issue-%23221", "app/models/repository.rb")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.raw("gitorious", "master", "lib/gitorious.rb")
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/raw/#{'a' * 40}:lib/gitorious.rb", header(response, "Location")
+    end
+  end
+
+  describe "#blame" do
+    it "delegates to lookup" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new)
+
+      dolt.blame("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "gitorious", lookup.repo
+      assert_equal "master", lookup.ref
+      assert_equal "app/models/repository.rb", lookup.path
+    end
+
+    it "renders the blame template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Text"))
+
+      response = dolt.blame("gitorious", "master", "app/models/repository.rb")
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "blame:Text", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Text")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Blob.new), renderer)
+
+      dolt.blame("gitorious", "master", "app/models/repository.rb", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Blob"))
+
+      dolt.blame("gitorious", "issue-%23221", "app/models/repository.rb")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.blame("gitorious", "master", "lib/gitorious.rb")
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/blame/#{'a' * 40}:lib/gitorious.rb", header(response, "Location")
+    end
+  end
+
+  describe "#history" do
+    it "delegates to lookup" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new)
+      dolt.history("gitorious", "master", "app/models/repository.rb", 10)
+
+      assert_equal "gitorious", lookup.repo
+      assert_equal "master", lookup.ref
+      assert_equal "app/models/repository.rb", lookup.path
+    end
+
+    it "renders the commits template as html" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Text"))
+
+      response = dolt.history("gitorious", "master", "app/models/repository.rb", 10)
+
+      assert_equal "text/html; charset=utf-8", header(response, "Content-Type")
+      assert_equal "commits:Text", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Text")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Blob.new), renderer)
+
+      dolt.history("gitorious", "master", "app/models/repository.rb", 10, { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Blob.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Blob"))
+
+      dolt.history("gitorious", "issue-%23221", "lib/gitorious.rb", 10)
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("Blob"))
+
+      response = dolt.history("gitorious", "master", "lib/gitorious.rb", 10)
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/history/#{'a' * 40}:lib/gitorious.rb", header(response, "Location")
+    end
+  end
+
+  describe "#refs" do
+    it "renders the refs template as json" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Blob.new), Test::Renderer.new("JSON"))
+
+      response = dolt.refs("gitorious")
+
+      assert_equal "application/json", header(response, "Content-Type")
+      assert_equal "refs:JSON", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Text")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Blob.new), renderer)
+
+      dolt.refs("gitorious", { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+  end
+
+  describe "#tree_history" do
+    it "renders the tree_history template as json" do
+      router = Test::Router.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("JSON"))
+
+      response = dolt.tree_history("gitorious", "master", "", 1)
+
+      assert_equal "application/json", header(response, "Content-Type")
+      assert_equal "tree_history:JSON", body(response)
+    end
+
+    it "renders template with custom data" do
+      renderer = Test::Renderer.new("Text")
+      dolt = Dolt::ControllerActions.new(Test::Router.new, Test::Lookup.new(Stub::Tree.new), renderer)
+
+      dolt.tree_history("gitorious", "master", "app/models", 1, { :who => 42 })
+
+      assert_equal 42, renderer.data[:who]
+    end
+
+    it "unescapes ref" do
+      lookup = Test::Lookup.new(Stub::Tree.new)
+      dolt = Dolt::ControllerActions.new(Test::Router.new, lookup, Test::Renderer.new("Tree"))
+
+      dolt.tree_history("gitorious", "issue-%23221", "app/models")
+
+      assert_equal "issue-#221", lookup.ref
+    end
+
+    it "redirects ref to oid if configured so" do
+      router = Test::RedirectingRouter.new
+      dolt = Dolt::ControllerActions.new(router, Test::Lookup.new(Stub::Tree.new), Test::Renderer.new("Tree"))
+
+      response = dolt.tree_history("gitorious", "master", "lib", 10)
+
+      assert_equal 307, status(response)
+      assert_equal "/gitorious/tree_history/#{'a' * 40}:lib", header(response, "Location")
+    end
+  end
+
+  def status(response)
+    response[0]
+  end
+
+  def header(response, name)
+    response[1][name]
+  end
+
+  def body(response)
+    response[2].join
+  end
+end

data/test/test_helper.rb

@@ -46,15 +46,15 @@ module Dolt
       root = File.join(File.dirname(__FILE__), "..", "views")
       renderer = Tiltout.new(root, options)
       renderer.helper(helpers || [Dolt::View::MultiRepository,
-                                  Dolt::View::Urls,
-                                  Dolt::View::Object,
-                                  Dolt::View::Blob,
-                                  Dolt::View::Tree,
-                                  Dolt::View::Blame,
-                                  Dolt::View::SyntaxHighlight,
-                                  Dolt::View::Commit,
-                                  Dolt::View::Gravatar,
-                                  Dolt::View::Breadcrumb])
+          Dolt::View::Urls,
+          Dolt::View::Object,
+          Dolt::View::Blob,
+          Dolt::View::Tree,
+          Dolt::View::Blame,
+          Dolt::View::SyntaxHighlight,
+          Dolt::View::Commit,
+          Dolt::View::Gravatar,
+          Dolt::View::Breadcrumb])
       renderer
     end
   end
@@ -80,3 +80,121 @@ module Dolt
     end
   end
 end
+
+module Stub
+  class Blob
+    def is_a?(type)
+      type == Rugged::Blob
+    end
+  end
+
+  class Tree
+    def is_a?(type)
+      type == Rugged::Tree
+    end
+  end
+end
+
+module Test
+  class Router
+    def tree_url(repo, ref, path)
+      "/#{repo}/tree/#{ref}:#{path}"
+    end
+
+    def blob_url(repo, ref, path)
+      "/#{repo}/blob/#{ref}:#{path}"
+    end
+
+    def tree_entry_url(repo, ref, path)
+      "/#{repo}/source/#{ref}:#{path}"
+    end
+
+    def blame_url(repo, ref, path)
+      "/#{repo}/blame/#{ref}:#{path}"
+    end
+
+    def history_url(repo, ref, path)
+      "/#{repo}/history/#{ref}:#{path}"
+    end
+
+    def tree_history_url(repo, ref, path)
+      "/#{repo}/tree_history/#{ref}:#{path}"
+    end
+
+    def raw_url(repo, ref, path)
+      "/#{repo}/raw/#{ref}:#{path}"
+    end
+
+    def method_missing(name, *args, &block)
+      @actions.send(name, *args, &block)
+    end
+  end
+
+  class RedirectingRouter < Router
+    def redirect_refs?; true; end
+  end
+
+  class Renderer
+    attr_reader :data
+    def initialize(body = ""); @body = body; end
+
+    def render(action, data, options = {})
+      @action = action
+      @data = data
+      "#{action}:#@body"
+    end
+  end
+
+  class Lookup
+    attr_reader :repo, :ref, :path
+
+    def initialize(response)
+      @response = response
+    end
+
+    def blob(repo, ref, path)
+      respond(:blob, repo, ref, path)
+    end
+
+    def tree(repo, ref, path)
+      respond(:tree, repo, ref, path)
+    end
+
+    def tree_entry(repo, ref, path)
+      respond(:tree_entry, repo, ref, path)
+    end
+
+    def raw(repo, ref, path)
+      respond(:raw, repo, ref, path)
+    end
+
+    def blame(repo, ref, path)
+      respond(:blame, repo, ref, path)
+    end
+
+    def history(repo, ref, path, limit)
+      respond(:history, repo, ref, path)
+    end
+
+    def refs(repo)
+      respond(:refs, repo)
+    end
+
+    def tree_history(repo, ref, path, count)
+      respond(:tree_history, repo, ref, path)
+    end
+
+    def respond(type, repo, ref = nil, path = nil)
+      @repo = repo
+      @ref = ref
+      @path = path
+      data = { :ref => ref, :repository => repo }
+      data[type != :tree_entry ? type : (@response.class.to_s =~ /Tree/ ? :tree : :blob)] = @response
+      data
+    end
+
+    def rev_parse_oid(repo, ref)
+      "a" * 40
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libdolt
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-15 00:00:00.000000000 Z
+date: 2013-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -201,6 +201,7 @@ files:
 - Rakefile
 - Readme.md
 - lib/libdolt.rb
+- lib/libdolt/controller_actions.rb
 - lib/libdolt/disk_repo_resolver.rb
 - lib/libdolt/git.rb
 - lib/libdolt/git/archiver.rb
@@ -210,7 +211,6 @@ files:
 - lib/libdolt/git/repository.rb
 - lib/libdolt/git/submodule.rb
 - lib/libdolt/git/tree.rb
-- lib/libdolt/gitorious_repo_resolver.rb
 - lib/libdolt/repository_lookup.rb
 - lib/libdolt/version.rb
 - lib/libdolt/view.rb
@@ -249,6 +249,7 @@ files:
 - test/fixtures/dolt-test-repo.git/objects/fc/5f5fb50b435e183925b341909610aace90a413
 - test/fixtures/dolt-test-repo.git/refs/heads/master
 - test/fixtures/dolt-test-repo.git/refs/tags/testable-tag
+- test/libdolt/controller_actions_test.rb
 - test/libdolt/disk_repo_resolver_test.rb
 - test/libdolt/git/archiver_test.rb
 - test/libdolt/git/blame_test.rb

data/lib/libdolt/gitorious_repo_resolver.rb

@@ -1,29 +0,0 @@
-# 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
-  class GitoriousRepoResolver
-    def initialize(repository)
-      @repository = repository
-    end
-
-    def resolve(repo = nil)
-      Dolt::Git::Repository.new(@repository.full_repository_path)
-    end
-  end
-end