dolt 0.1.1 → 0.2.0

data/lib/dolt/git/repository.rb

@@ -15,44 +15,46 @@
 #   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/async/when"
-require "dolt/git/blob"
-require "dolt/git/tree"
+require "em_rugged/repository"
+require "em_pessimistic/deferrable_child_process"
+require "em/deferrable"
+require "dolt/git/blame"
+require "dolt/git/commit"
 
 module Dolt
   module Git
-    class Repository
-      attr_reader :name
-
-      def initialize(name, git = nil)
-        @name = name
-        @git = git
-      end
-
-      def blob(path, ref = "HEAD")
-        async_git(git.show(path, ref)) do |data, status|
-          Dolt::Git::Blob.new(path, data)
+    class Repository < EMRugged::Repository
+      def blame(ref, path)
+        deferred_method("blame -l -t -p #{ref} #{path}") do |output, s|
+          Dolt::Git::Blame.parse_porcelain(output)
         end
       end
 
-      def tree(path, ref = "HEAD")
-        async_git(git.ls_tree(path, ref)) do |data, status|
-          Dolt::Git::Tree.parse(path, data)
+      def log(ref, path, limit)
+        deferred_method("log -n #{limit} #{ref} #{path}") do |out, s|
+          Dolt::Git::Commit.parse_log(out)
         end
       end
 
       private
-      def git; @git; end
+      def deferred_method(cmd, &block)
+        d = EventMachine::DefaultDeferrable.new
+        cmd = git(cmd)
+        p = EMPessimistic::DeferrableChildProcess.open(cmd)
 
-      def async_git(gitop, &block)
-        deferred = When::Deferred.new
+        p.callback do |output, status|
+          d.succeed(block.call(output, status))
+        end
 
-        gitop.callback do |data, status|
-          deferred.resolve(block.call(data, status))
+        p.errback do |err|
+          d.fail(err)
         end
 
-        gitop.errback { |err| deferred.reject(err) }
-        deferred.promise
+        d
+      end
+
+      def git(cmd)
+        "git --git-dir #{subject.path} #{cmd}"
       end
     end
   end

data/lib/dolt/repo_actions.rb

@@ -23,31 +23,44 @@ module Dolt
       @repo_resolver = repo_resolver
     end
 
-    def blob(repo, path, ref, &block)
-      repository = repo_resolver.resolve(repo)
-      d = repository.blob(path, ref)
-      d.callback do |blob, status|
-        block.call(nil, {
-                     :blob => blob,
-                     :repository => repository,
-                     :ref => ref })
-      end
-      d.errback { |err| block.call(err, nil) }
+    def blob(repo, ref, path, &block)
+      repo_action(repo, ref, path, :blob, :rev_parse, "#{ref}:#{path}", &block)
+    end
+
+    def tree(repo, ref, path, &block)
+      repo_action(repo, ref, path, :tree, :rev_parse, "#{ref}:#{path}", &block)
+    end
+
+    def blame(repo, ref, path, &block)
+      repo_action(repo, ref, path, :blame, :blame, ref, path, &block)
+    end
+
+    def history(repo, ref, path, count, &block)
+      repo_action(repo, ref, path, :commits, :log, ref, path, count, &block)
     end
 
-    def tree(repo, path, ref, &block)
+    def repositories
+      repo_resolver.all
+    end
+
+    private
+    def repo_resolver; @repo_resolver; end
+
+    def repo_action(repo, ref, path, data, method, *args, &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 })
+      d = repository.send(method, *args)
+      d.callback do |result|
+        block.call(nil, tpl_data(repo, ref, path, { data => result }))
       end
       d.errback { |err| block.call(err, nil) }
     end
 
-    private
-    def repo_resolver; @repo_resolver; end
+    def tpl_data(repo, ref, path, locals = {})
+      {
+        :repository => repo,
+        :path => path,
+        :ref => ref
+      }.merge(locals)
+    end
   end
 end

data/lib/dolt/sinatra/actions.rb

@@ -15,33 +15,66 @@
 #   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 "em_rugged"
+
 module Dolt
   module Sinatra
     module Actions
-      def error(status)
+      # Built-in redirect seems to not work with Sinatra::Async, it throws
+      # an error.
+      def redirect(url)
+        response.status = 302
+        response["Location"] = url
+        body ""
+      end
+
+      def error(error)
         response["Content-Type"] = "text/plain"
-        body("Process failed with exit code \n#{status.exitstatus}")
+        body("Process failed with exit code #{error.exit_code}:\n#{error.message}")
+      end
+
+      def raw(repo, ref, path)
+        blob(repo, ref, path, {
+               :template => :raw,
+               :content_type => "text/plain",
+               :template_options => { :layout => nil }
+             })
+      end
+
+      def blob(repo, ref, path, options = { :template => :blob, :content_type => "text/html" })
+        actions.blob(repo, ref, path) do |err, data|
+          return error(err) if !err.nil?
+          blob = data[:blob]
+          return redirect(tree_url(repo, ref, path)) if !blob.is_a?(Rugged::Blob)
+          response["Content-Type"] = options[:content_type]
+          tpl_options = options[:template_options] || {}
+          body(renderer.render(options[:template], data, tpl_options))
+        end
+      end
+
+      def tree(repo, ref, path)
+        actions.tree(repo, ref, path) do |err, data|
+          return error(err) if !err.nil?
+          tree = data[:tree]
+          return redirect(blob_url(repo, ref, path)) if !tree.is_a?(Rugged::Tree)
+          response["Content-Type"] = "text/html"
+          body(renderer.render(:tree, data))
+        end
       end
 
-      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))
-          else
-            error(status)
-          end
+      def blame(repo, ref, path)
+        actions.blame(repo, ref, path) do |err, data|
+          return error(err) if !err.nil?
+          response["Content-Type"] = "text/html"
+          body(renderer.render(:blame, data))
         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
+      def history(repo, ref, path, count)
+        actions.history(repo, ref, path, count) do |err, data|
+          return error(err) if !err.nil?
+          response["Content-Type"] = "text/html"
+          body(renderer.render(:commits, data))
         end
       end
     end

data/lib/dolt/sinatra/multi_repo_browser.rb

@@ -16,17 +16,25 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 require "dolt/sinatra/base"
+require "dolt/view/single_repository"
+require "dolt/view/blob"
+require "dolt/view/tree"
 
 module Dolt
   module Sinatra
     class MultiRepoBrowser < Dolt::Sinatra::Base
+      include Dolt::View::SingleRepository
+      include Dolt::View::Blob
+      include Dolt::View::Tree
+
       aget "/" do
         response["Content-Type"] = "text/html"
-        body("<h1>Welcome to Dolt</h1>")
+        body(renderer.render(:index, { :repositories => actions.repositories }))
       end
 
       aget "/*/tree/*:*" do
-        tree(params[:splat][0], params[:splat][2], params[:splat][1])
+        repo, ref, path = params[:splat]
+        tree(repo, ref, path)
       end
 
       aget "/*/tree/*" do
@@ -34,13 +42,32 @@ module Dolt
       end
 
       aget "/*/blob/*:*" do
-        blob(params[:splat][0], params[:splat][2], params[:splat][1])
+        repo, ref, path = params[:splat]
+        blob(repo, ref, path)
       end
 
       aget "/*/blob/*" do
         force_ref(params[:splat], "blob", "master")
       end
 
+      aget "/*/raw/*:*" do
+        repo, ref, path = params[:splat]
+        raw(repo, ref, path)
+      end
+
+      aget "/*/raw/*" do
+        force_ref(params[:splat], "raw", "master")
+      end
+
+      aget "/*/blame/*:*" do
+        repo, ref, path = params[:splat]
+        blame(repo, ref, path)
+      end
+
+      aget "/*/blame/*" do
+        force_ref(params[:splat], "blame", "master")
+      end
+
       private
       def force_ref(args, action, ref)
         redirect(args.shift + "/#{action}/#{ref}:" + args.join)

data/lib/dolt/sinatra/single_repo_browser.rb

@@ -16,10 +16,16 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 require "dolt/sinatra/base"
+require "dolt/view/single_repository"
+require "dolt/view/blob"
+require "dolt/view/tree"
 
 module Dolt
   module Sinatra
     class SingleRepoBrowser < Dolt::Sinatra::Base
+      include Dolt::View::SingleRepository
+      include Dolt::View::Blob
+      include Dolt::View::Tree
       attr_reader :repo
 
       def initialize(repo, actions, renderer)
@@ -32,7 +38,8 @@ module Dolt
       end
 
       aget "/tree/*:*" do
-        tree(repo, params[:splat][1], params[:splat][0])
+        ref, path = params[:splat]
+        tree(repo, ref, path)
       end
 
       aget "/tree/*" do
@@ -41,13 +48,40 @@ module Dolt
 
       aget "/blob/*:*" do
         ref, path = params[:splat]
-        blob(repo, path, ref)
+        blob(repo, ref, path)
       end
 
       aget "/blob/*" do
         force_ref(params[:splat], "blob", "master")
       end
 
+      aget "/raw/*:*" do
+        ref, path = params[:splat]
+        raw(repo, ref, path)
+      end
+
+      aget "/raw/*" do
+        force_ref(params[:splat], "raw", "master")
+      end
+
+      aget "/blame/*:*" do
+        ref, path = params[:splat]
+        blame(repo, ref, path)
+      end
+
+      aget "/blame/*" do
+        force_ref(params[:splat], "blame", "master")
+      end
+
+      aget "/history/*:*" do
+        ref, path = params[:splat]
+        history(repo, ref, path, (params[:commit_count] || 20).to_i)
+      end
+
+      aget "/history/*" do
+        force_ref(params[:splat], "blame", "master")
+      end
+
       private
       def force_ref(args, action, ref)
         redirect("/#{action}/#{ref}:" + args.join)

data/lib/dolt/template_renderer.rb

@@ -25,20 +25,20 @@ module Dolt
       @layout = opt[:layout]
       @type = opt[:type] || "erb"
       @context_class = Class.new
-      @attributes = opt[:attributes] || {}
     end
 
-    def helper(helper_module)
-      @context_class.send(:include, helper_module)
+    def helper(helper)
+      helper = [helper] unless Array === helper
+      helper.each { |h| @context_class.send(:include, h) }
     end
 
-    def render(template, locals = {})
-      locals = locals.merge(attributes)
+    def render(template, locals = {}, options = {})
       context = context_class.new
       content = load(template).render(context, locals)
+      layout_tpl = options.key?(:layout) ? options[:layout] : layout
 
-      if !layout.nil?
-        content = load(layout).render(context, locals) { content }
+      if !layout_tpl.nil?
+        content = load(layout_tpl).render(context, locals) { content }
       end
 
       content
@@ -58,6 +58,5 @@ 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.1"
+  VERSION = "0.2.0"
 end

data/lib/dolt/view.rb

@@ -15,67 +15,9 @@
 #   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/view/breadcrumb"
-require "dolt/view/highlighter"
 
-module Dolt
-  module View
-    def breadcrumb(repository, path, ref, options = {})
-      bc = Dolt::View::Breadcrumb.new(:multi_repo_mode => options[:multi_repo_mode])
-      bc.render(repository, ref, path)
-    end
+dir = File.join(File.dirname(__FILE__), "view")
 
-    def multiline(blob, options = {})
-      class_names = options[:class_names] || []
-      class_names << "prettyprint" << "linenums"
-
-      num = 0
-      lines = blob.split("\n").inject("") do |html, line|
-        num += 1
-        "#{html}<li class=\"L#{num}\"><span class=\"line\">#{line}</span></li>"
-      end
-
-      "<pre class=\"#{class_names.join(' ')}\">" +
-        "<ol class=\"linenums\">#{lines}</ol></pre>"
-    end
-
-    def highlight(path, code, options = {})
-      lexer = lexer_for_file(path)
-      Dolt::View::Highlighter.new(options).highlight(code, lexer)
-    rescue RubyPython::PythonError
-      code
-    end
-
-    def highlight_lines(path, code, options = {})
-      lexer = lexer_for_file(path)
-      multiline(highlight(path, code, options), :class_names => [lexer])
-    end
-
-    def lexer_for_file(path)
-      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
+Dir.entries(dir).select { |f| f =~ /\.rb$/ }.map do |file|
+  require(File.join(dir, file))
 end