dolt 0.25.0 → 0.26.0

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    dolt (0.25.0)
+    dolt (0.26.0)
       json (~> 1.5)
-      libdolt (~> 0.23)
+      libdolt (~> 0.26)
       sinatra (~> 1.0)
       thin (~> 1.4)
       tiltout (~> 1.4)
@@ -13,29 +13,37 @@ GEM
   remote: http://rubygems.org/
   specs:
     builder (3.2.2)
+    charlock_holmes (0.6.9.4)
     ci_reporter (1.9.0)
       builder (>= 2.1.2)
     daemons (1.1.9)
+    escape_utils (0.3.2)
     eventmachine (1.0.3)
+    github-linguist (2.8.5)
+      charlock_holmes (~> 0.6.6)
+      escape_utils (~> 0.3.1)
+      mime-types (~> 1.19)
+      pygments.rb (~> 0.4.2)
     github-markup (0.7.5)
     htmlentities (4.3.1)
     json (1.8.0)
-    libdolt (0.24.0)
+    libdolt (0.26.0)
       htmlentities (~> 4.3)
       json (~> 1.7)
-      makeup (~> 0.2)
+      makeup (~> 0.4)
       mime-types (~> 1.19)
       rugged (= 0.18.0.gh.de28323)
       tzinfo (~> 0.3)
-    makeup (0.3.0)
+    makeup (0.4.0)
+      github-linguist (~> 2.8)
       github-markup (~> 0.7)
       htmlentities (~> 4.3)
-      pygments.rb (~> 0.2)
+      pygments.rb (~> 0.4)
     mime-types (1.23)
     minitest (2.12.1)
     multi_json (1.7.7)
     posix-spawn (0.3.6)
-    pygments.rb (0.5.1)
+    pygments.rb (0.4.2)
       posix-spawn (~> 0.3.6)
       yajl-ruby (~> 1.1.0)
     rack (1.5.2)

data/bin/dolt

@@ -21,16 +21,16 @@ class DoltApp
     if is_git_repo?(dir)
       dir = File.expand_path(dir)
       resolver = Dolt::DiskRepoResolver.new(File.dirname(dir))
-      actions = Dolt::RepoActions.new(resolver)
+      lookup = Dolt::RepositoryLookup.new(resolver)
       view.helper(Dolt::View::SingleRepository)
       require "dolt/sinatra/single_repo_browser"
-      Dolt::Sinatra::SingleRepoBrowser.new(File.basename(dir), actions, view)
+      Dolt::Sinatra::SingleRepoBrowser.new(File.basename(dir), lookup, view)
     else
       resolver = Dolt::DiskRepoResolver.new(dir)
-      actions = Dolt::RepoActions.new(resolver)
+      lookup = Dolt::RepositoryLookup.new(resolver)
       view.helper(Dolt::View::MultiRepository)
       require "dolt/sinatra/multi_repo_browser"
-      Dolt::Sinatra::MultiRepoBrowser.new(actions, view)
+      Dolt::Sinatra::MultiRepoBrowser.new(lookup, view)
     end
   end
 

data/dolt.gemspec

@@ -11,7 +11,7 @@ end
 
 Gem::Specification.new do |s|
   s.name        = "dolt"
-  s.version     = "0.25.0"
+  s.version     = "0.26.0"
   s.authors     = ["Christian Johansen"]
   s.email       = ["christian@gitorious.org"]
   s.homepage    = "http://gitorious.org/gitorious/dolt"
@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "dolt"
 
-  s.add_dependency "libdolt", "~>0.23"
+  s.add_dependency "libdolt", "~>0.26"
   s.add_dependency "thin", "~>1.4"
   s.add_dependency "sinatra", "~>1.0"
   s.add_dependency "tiltout", "~>1.4"

data/lib/dolt/sinatra/actions.rb

@@ -21,32 +21,38 @@ require "cgi"
 
 module Dolt
   module Sinatra
-    module Actions
+    class Actions
+      def initialize(app, lookup, renderer)
+        @app = app
+        @lookup = lookup
+        @renderer = renderer
+      end
+
       def redirect(url, status = 302)
-        response.status = status
-        response["Location"] = url
-        body ""
+        app.response.status = status
+        app.response["Location"] = url
+        app.body("")
       end
 
       def render_error(error, repo, ref, data = {})
         if error.class.to_s == "Rugged::ReferenceError" && ref == "HEAD"
-          return body(renderer.render("empty", {
+          return app.body(renderer.render("empty", {
                 :repository => repo,
                 :ref => ref
               }.merge(data)))
         end
         template = error.class.to_s == "Rugged::IndexerError" ? :"404" : :"500"
-        add_headers(response)
-        body(renderer.render(template, {
-                               :error => error,
-                               :repository_slug => repo,
-                               :ref => ref
-                             }.merge(data)))
+        add_headers(app.response)
+        app.body(renderer.render(template, {
+              :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>" }
 
-        body(<<-HTML)
+        app.body(<<-HTML)
         <h1>Fatal Dolt Error</h1>
         <p>
           Dolt encountered an exception, and additionally
@@ -68,98 +74,100 @@ module Dolt
 
       def raw(repo, ref, path, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(raw_url(repo, oid, path), 307) and return
+          redirect(app.raw_url(repo, oid, path), 307) and return
         end
 
         blob(repo, ref, path, custom_data, {
-               :template => :raw,
-               :content_type => "text/plain",
-               :template_options => { :layout => nil }
-             })
+            :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)
-          redirect(blob_url(repo, oid, path), 307) and return
+          redirect(app.blob_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.blob(repo, u(ref), path))
+        data = (custom_data || {}).merge(lookup.blob(repo, u(ref), path))
         blob = data[:blob]
-        return redirect(tree_url(repo, ref, path)) if blob.class.to_s !~ /\bBlob/
-        add_headers(response, options.merge(:ref => ref))
+        return redirect(app.tree_url(repo, ref, path)) if blob.class.to_s !~ /\bBlob/
+        add_headers(app.response, options.merge(:ref => ref))
         tpl_options = options[:template_options] || {}
-        body(renderer.render(options[:template], data, tpl_options))
+        app.body(renderer.render(options[:template], data, tpl_options))
       end
 
       def tree(repo, ref, path, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(tree_url(repo, oid, path), 307) and return
+          redirect(app.tree_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.tree(repo, u(ref), path))
+        data = (custom_data || {}).merge(lookup.tree(repo, u(ref), path))
         tree = data[:tree]
-        return redirect(blob_url(repo, ref, path)) if tree.class.to_s !~ /\bTree/
-        add_headers(response, :ref => ref)
-        body(renderer.render(:tree, data))
+        return redirect(app.blob_url(repo, ref, path)) if tree.class.to_s !~ /\bTree/
+        add_headers(app.response, :ref => ref)
+        app.body(renderer.render(:tree, data))
       end
 
       def tree_entry(repo, ref, path, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(tree_entry_url(repo, oid, path), 307) and return
+          redirect(app.tree_entry_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.tree_entry(repo, u(ref), path))
-        add_headers(response, :ref => ref)
-        body(renderer.render(data.key?(:tree) ? :tree : :blob, data))
+        data = (custom_data || {}).merge(lookup.tree_entry(repo, u(ref), path))
+        add_headers(app.response, :ref => ref)
+        app.body(renderer.render(data.key?(:tree) ? :tree : :blob, data))
       end
 
       def blame(repo, ref, path, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(blame_url(repo, oid, path), 307) and return
+          redirect(app.blame_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.blame(repo, u(ref), path))
-        add_headers(response, :ref => ref)
-        body(renderer.render(:blame, data))
+        data = (custom_data || {}).merge(lookup.blame(repo, u(ref), path))
+        add_headers(app.response, :ref => ref)
+        app.body(renderer.render(:blame, data))
       end
 
       def history(repo, ref, path, count, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(history_url(repo, oid, path), 307) and return
+          redirect(app.history_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.history(repo, u(ref), path, count))
-        add_headers(response, :ref => ref)
-        body(renderer.render(:commits, data))
+        data = (custom_data || {}).merge(lookup.history(repo, u(ref), path, count))
+        add_headers(app.response, :ref => ref)
+        app.body(renderer.render(:commits, data))
       end
 
       def refs(repo, custom_data = {})
-        data = (custom_data || {}).merge(actions.refs(repo))
-        add_headers(response, :content_type => "application/json")
-        body(renderer.render(:refs, data, :layout => nil))
+        data = (custom_data || {}).merge(lookup.refs(repo))
+        add_headers(app.response, :content_type => "application/json")
+        app.body(renderer.render(:refs, data, :layout => nil))
       end
 
       def tree_history(repo, ref, path, count = 1, custom_data = {})
         if oid = lookup_ref_oid(repo, ref)
-          redirect(tree_history_url(repo, oid, path), 307) and return
+          redirect(app.tree_history_url(repo, oid, path), 307) and return
         end
 
-        data = (custom_data || {}).merge(actions.tree_history(repo, u(ref), path, count))
-        add_headers(response, :content_type => "application/json", :ref => ref)
-        body(renderer.render(:tree_history, data, :layout => nil))
+        data = (custom_data || {}).merge(lookup.tree_history(repo, u(ref), path, count))
+        add_headers(app.response, :content_type => "application/json", :ref => ref)
+        app.body(renderer.render(:tree_history, data, :layout => nil))
       end
 
       def resolve_repository(repo)
         @cache ||= {}
-        @cache[repo] ||= actions.resolve_repository(repo)
+        @cache[repo] ||= lookup.resolve_repository(repo)
       end
 
       def lookup_ref_oid(repo, ref)
-        return if !respond_to?(:redirect_refs?) || !redirect_refs? || ref.length == 40
-        actions.rev_parse_oid(repo, ref)
+        return if !app.respond_to?(:redirect_refs?) || !app.redirect_refs? || ref.length == 40
+        lookup.rev_parse_oid(repo, ref)
       end
 
       private
+      attr_reader :app, :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

data/lib/dolt/sinatra/multi_repo_browser.rb

@@ -15,23 +15,31 @@
 #   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 "dolt/sinatra/base"
+require "sinatra/base"
+require "dolt/sinatra/actions"
 require "libdolt/view/multi_repository"
 require "libdolt/view/blob"
 require "libdolt/view/tree"
 
 module Dolt
   module Sinatra
-    class MultiRepoBrowser < Dolt::Sinatra::Base
+    class MultiRepoBrowser < ::Sinatra::Base
       include Dolt::View::MultiRepository
       include Dolt::View::Blob
       include Dolt::View::Tree
 
+      def initialize(lookup, renderer)
+        @lookup = lookup
+        @renderer = renderer
+        @dolt = Dolt::Sinatra::Actions.new(self, lookup, renderer)
+        super()
+      end
+
       not_found { renderer.render("404") }
 
       get "/" do
         response["Content-Type"] = "text/html"
-        body(renderer.render(:index, { :repositories => actions.repositories }))
+        body(renderer.render(:index, { :repositories => lookup.repositories }))
       end
 
       get "/:repo" do
@@ -41,86 +49,88 @@ module Dolt
       get "/*/tree/*:*" do
         begin
           repo, ref, path = params[:splat]
-          tree(repo, ref, path)
+          dolt.tree(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/*/tree/*" do
-        force_ref(params[:splat], "tree", "HEAD")
+        dolt.force_ref(params[:splat], "tree", "HEAD")
       end
 
       get "/*/blob/*:*" do
         begin
           repo, ref, path = params[:splat]
-          blob(repo, ref, path)
+          dolt.blob(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/*/blob/*" do
-        force_ref(params[:splat], "blob", "HEAD")
+        dolt.force_ref(params[:splat], "blob", "HEAD")
       end
 
       get "/*/raw/*:*" do
         begin
           repo, ref, path = params[:splat]
-          raw(repo, ref, path)
+          dolt.raw(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/*/raw/*" do
-        force_ref(params[:splat], "raw", "HEAD")
+        dolt.force_ref(params[:splat], "raw", "HEAD")
       end
 
       get "/*/blame/*:*" do
         begin
           repo, ref, path = params[:splat]
-          blame(repo, ref, path)
+          dolt.blame(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/*/blame/*" do
-        force_ref(params[:splat], "blame", "HEAD")
+        dolt.force_ref(params[:splat], "blame", "HEAD")
       end
 
       get "/*/history/*:*" do
         begin
           repo, ref, path = params[:splat]
-          history(repo, ref, path, (params[:commit_count] || 20).to_i)
+          dolt.history(repo, ref, path, (params[:commit_count] || 20).to_i)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/*/history/*" do
-        force_ref(params[:splat], "history", "HEAD")
+        dolt.force_ref(params[:splat], "history", "HEAD")
       end
 
       get "/*/refs" do
         begin
-          refs(params[:splat].first)
+          dolt.refs(params[:splat].first)
         rescue Exception => err
-          render_error(err, repo, nil)
+          dolt.render_error(err, repo, nil)
         end
       end
 
       get "/*/tree_history/*:*" do
         begin
           repo, ref, path = params[:splat]
-          tree_history(repo, ref, path)
+          dolt.tree_history(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       private
+      attr_reader :repo, :lookup, :renderer, :dolt
+
       def force_ref(args, action, ref)
         redirect(args.shift + "/#{action}/#{ref}:" + args.join)
       end

data/lib/dolt/sinatra/single_repo_browser.rb

@@ -15,22 +15,25 @@
 #   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 "dolt/sinatra/base"
+require "sinatra/base"
+require "dolt/sinatra/actions"
 require "libdolt/view/single_repository"
 require "libdolt/view/blob"
 require "libdolt/view/tree"
 
 module Dolt
   module Sinatra
-    class SingleRepoBrowser < Dolt::Sinatra::Base
+    class SingleRepoBrowser < ::Sinatra::Base
       include Dolt::View::SingleRepository
       include Dolt::View::Blob
       include Dolt::View::Tree
-      attr_reader :repo
 
-      def initialize(repo, actions, renderer)
+      def initialize(repo, lookup, renderer)
         @repo = repo
-        super(actions, renderer)
+        @lookup = lookup
+        @renderer = renderer
+        @dolt = Dolt::Sinatra::Actions.new(self, lookup, renderer)
+        super()
       end
 
       not_found { renderer.render("404") }
@@ -42,86 +45,88 @@ module Dolt
       get "/tree/*:*" do
         begin
           ref, path = params[:splat]
-          tree(repo, ref, path)
+          dolt.tree(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/tree/*" do
-        force_ref(params[:splat], "tree", "HEAD")
+        dolt.force_ref(params[:splat], "tree", "HEAD")
       end
 
       get "/blob/*:*" do
         begin
           ref, path = params[:splat]
-          blob(repo, ref, path)
+          dolt.blob(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/blob/*" do
-        force_ref(params[:splat], "blob", "HEAD")
+        dolt.force_ref(params[:splat], "blob", "HEAD")
       end
 
       get "/raw/*:*" do
         begin
           ref, path = params[:splat]
-          raw(repo, ref, path)
+          dolt.raw(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/raw/*" do
-        force_ref(params[:splat], "raw", "HEAD")
+        dolt.force_ref(params[:splat], "raw", "HEAD")
       end
 
       get "/blame/*:*" do
         begin
           ref, path = params[:splat]
-          blame(repo, ref, path)
+          dolt.blame(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/blame/*" do
-        force_ref(params[:splat], "blame", "HEAD")
+        dolt.force_ref(params[:splat], "blame", "HEAD")
       end
 
       get "/history/*:*" do
         begin
           ref, path = params[:splat]
-          history(repo, ref, path, (params[:commit_count] || 20).to_i)
+          dolt.history(repo, ref, path, (params[:commit_count] || 20).to_i)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/history/*" do
-        force_ref(params[:splat], "blame", "HEAD")
+        dolt.force_ref(params[:splat], "blame", "HEAD")
       end
 
       get "/refs" do
         begin
-          refs(repo)
+          dolt.refs(repo)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       get "/tree_history/*:*" do
         begin
           ref, path = params[:splat]
-          tree_history(repo, ref, path)
+          dolt.tree_history(repo, ref, path)
         rescue Exception => err
-          render_error(err, repo, ref)
+          dolt.render_error(err, repo, ref)
         end
       end
 
       private
+      attr_reader :repo, :lookup, :renderer, :dolt
+
       def force_ref(args, action, ref)
         redirect("/#{action}/#{ref}:" + args.join)
       end