dolt 0.3.1 → 0.4.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dolt (0.3.1)
+    dolt (0.4.0)
       async_sinatra (~> 1.0)
       builder (~> 3.1)
       em_pessimistic (~> 0.1)

data/lib/dolt/async/when.rb

@@ -33,6 +33,10 @@ module When
       @deferred.fail(*args)
     end
 
+    def resolved?
+      @resolved
+    end
+
     private
     def mark_resolved
       raise StandardError.new("Already resolved") if @resolved
@@ -65,23 +69,60 @@ module When
       @promise.errback(&block)
     end
 
+    def resolved?
+      @resolver.resolved?
+    end
+
     def self.resolved(value)
       d = self.new
-      d.resolve(vaule)
+      d.resolve(value)
       d
     end
 
     def self.rejected(value)
       d = self.new
-      d.reject(vaule)
+      d.reject(value)
       d
     end
   end
 
-  module Functions
-    def deferred(val)
-      return val if val.respond_to?(:callback) && val.respond_to?(:errback)
-      Deferred.resolved(val).promise
+  def self.deferred(val)
+    return val if val.respond_to?(:callback) && val.respond_to?(:errback)
+    Deferred.resolved(val).promise
+  end
+
+  def self.all(promises)
+    raise(ArgumentError, "expected enumerable promises") if !promises.is_a?(Enumerable)
+    resolved = 0
+    results = []
+    d = Deferred.new
+
+    attempt_resolution = lambda do |err, res|
+      break if d.resolved?
+      if err.nil?
+        d.resolve(res) if promises.length == resolved
+      else
+        d.reject(err)
+      end
+    end
+
+    wait_for_all(promises) do |err, result, index|
+      resolved += 1
+      results[index] = result
+      attempt_resolution.call(err, results)
+    end
+
+    attempt_resolution.call(nil, results) if promises.length == 0
+    d.promise
+  end
+
+  private
+  def self.wait_for_all(promises, &block)
+    promises.each_with_index do |p, i|
+      p.callback do |result|
+        block.call(nil, result, i)
+      end
+      p.errback { |e| block.call(e, nil, i) }
     end
   end
 end

data/lib/dolt/git/commit.rb

@@ -56,7 +56,7 @@ module Dolt
       def self.extract_commit_summary(lines)
         summary = lines.shift
         lines.shift if lines.first == ""
-        summary
+        summary.sub(/^    /, "")
       end
 
       def self.extract_commit_message(lines)

data/lib/dolt/git/repository.rb

@@ -20,6 +20,7 @@ require "em_pessimistic/deferrable_child_process"
 require "em/deferrable"
 require "dolt/git/blame"
 require "dolt/git/commit"
+require "dolt/async/when"
 
 module Dolt
   module Git
@@ -31,12 +32,46 @@ module Dolt
       end
 
       def log(ref, path, limit)
-        deferred_method("log -n #{limit} #{ref} #{path}") do |out, s|
-          Dolt::Git::Commit.parse_log(out)
+        entry_history(ref, path, limit)
+      end
+
+      def tree_history(ref, path, limit = 1)
+        d = EventMachine::DefaultDeferrable.new
+        rp = rev_parse("#{ref}:#{path}")
+        rp.errback { |err| d.fail(err) }
+        rp.callback do |tree|
+          if tree.class != Rugged::Tree
+            message = "#{ref}:#{path} is not a tree (#{tree.class.to_s})"
+            break d.fail(Exception.new(message))
+          end
+
+          building = build_history(path || "./", ref, tree, limit)
+          building.callback { |history| d.succeed(history) }
+          building.errback { |err| d.fail(err) }
         end
+        d
       end
 
       private
+      def entry_history(ref, entry, limit)
+        deferred_method("log -n #{limit} #{ref} #{entry}") do |out, s|
+          Dolt::Git::Commit.parse_log(out)
+        end
+      end
+
+      def build_history(path, ref, entries, limit)
+        d = EventMachine::DefaultDeferrable.new
+        resolve = lambda { |p| path == "" ? p : File.join(path, p) }
+        progress = When.all(entries.map do |e|
+                              entry_history(ref, resolve.call(e[:name]), limit)
+                            end)
+        progress.errback { |e| d.fail(e) }
+        progress.callback do |history|
+          d.succeed(entries.map { |e| e.merge({ :history => history.shift }) })
+        end
+        d
+      end
+
       def deferred_method(cmd, &block)
         d = EventMachine::DefaultDeferrable.new
         cmd = git(cmd)
@@ -46,8 +81,8 @@ module Dolt
           d.succeed(block.call(output, status))
         end
 
-        p.errback do |err|
-          d.fail(err)
+        p.errback do |stderr, status|
+          d.fail(stderr)
         end
 
         d

data/lib/dolt/repo_actions.rb

@@ -1,3 +1,4 @@
+
 # encoding: utf-8
 #--
 #   Copyright (C) 2012 Gitorious AS
@@ -53,6 +54,10 @@ module Dolt
       d.errback { |err| block.call(err, nil) }
     end
 
+    def tree_history(repo, ref, path, count, &block)
+      repo_action(repo, ref, path, :tree, :tree_history, ref, path, count, &block)
+    end
+
     def repositories
       repo_resolver.all
     end

data/lib/dolt/sinatra/actions.rb

@@ -89,6 +89,17 @@ module Dolt
           body(renderer.render(:refs, data, :layout => nil))
         end
       end
+
+      def tree_history(repo, ref, path, count = 1)
+        actions.tree_history(repo, ref, path, count) do |err, data|
+          if !err.nil?
+            error(err, repo, ref)
+          else
+            response["Content-Type"] = "application/json"
+            body(renderer.render(:tree_history, data, :layout => nil))
+          end
+        end
+      end
     end
   end
 end

data/lib/dolt/sinatra/multi_repo_browser.rb

@@ -68,10 +68,24 @@ module Dolt
         force_ref(params[:splat], "blame", "master")
       end
 
+      aget "/*/history/*:*" do
+        repo, ref, path = params[:splat]
+        history(repo, ref, path, (params[:commit_count] || 20).to_i)
+      end
+
+      aget "/*/history/*" do
+        force_ref(params[:splat], "history", "master")
+      end
+
       aget "/*/refs" do
         refs(params[:splat].first)
       end
 
+      aget "/*/tree_history/*:*" do
+        repo, ref, path = params[:splat]
+        tree_history(repo, ref, path)
+      end
+
       private
       def force_ref(args, action, ref)
         redirect(args.shift + "/#{action}/#{ref}:" + args.join)

data/lib/dolt/sinatra/single_repo_browser.rb

@@ -86,6 +86,11 @@ module Dolt
         refs(repo)
       end
 
+      aget "/tree_history/*:*" do
+        ref, path = params[:splat]
+        tree_history(repo, ref, path)
+      end
+
       private
       def force_ref(args, action, ref)
         redirect("/#{action}/#{ref}:" + args.join)

data/lib/dolt/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Dolt
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/dolt/view/blob.rb

@@ -67,6 +67,10 @@ The content you're attempting to browse appears to be binary.
         repo_url(repository, "/raw/#{ref}:#{path}")
       end
 
+      def tree_history_url(repository, ref, path)
+        repo_url(repository, "/tree_history/#{ref}:#{path}")
+      end
+
       def format_whitespace(text)
         text
       end

data/test/dolt/async/when_test.rb

@@ -0,0 +1,112 @@
+# 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/async/when"
+
+describe When do
+  include EM::MiniTest::Spec
+
+  describe ".all" do
+    it "returns deferrable" do
+      d = When.all([When.deferred(42)])
+      assert d.respond_to?(:callback)
+      assert d.respond_to?(:errback)
+    end
+
+    it "resolves immediately if no promises" do
+      d = When.all([])
+      d.callback do |results|
+        assert_equal [], results
+        done!
+      end
+      wait!
+    end
+
+    it "resolves when single deferrable resolves" do
+      deferred = When::Deferred.new
+      d = When.all([deferred.promise])
+      resolved = false
+      d.callback { |results| resolved = true }
+
+      assert !resolved
+      deferred.resolve(42)
+      assert resolved
+    end
+
+    it "resolves when all deferrables are resolved" do
+      deferreds = [When::Deferred.new, When::Deferred.new, When::Deferred.new]
+      d = When.all(deferreds.map(&:promise))
+      resolved = false
+      d.callback { |results| resolved = true }
+
+      assert !resolved
+      deferreds[0].resolve(42)
+      assert !resolved
+      deferreds[1].resolve(13)
+      assert !resolved
+      deferreds[2].resolve(3)
+      assert resolved
+    end
+
+    it "rejects when single deferrable rejects" do
+      deferred = When::Deferred.new
+      d = When.all([deferred.promise])
+      rejected = false
+      d.errback { |results| rejected = true }
+
+      assert !rejected
+      deferred.reject(StandardError.new)
+      assert rejected
+    end
+
+    it "rejects on first rejection" do
+      deferreds = [When::Deferred.new, When::Deferred.new, When::Deferred.new]
+      d = When.all(deferreds.map(&:promise))
+      rejected = false
+      d.errback { |results| rejected = true }
+
+      deferreds[0].resolve(42)
+      deferreds[2].reject(StandardError.new)
+      deferreds[1].resolve(13)
+
+      assert rejected
+    end
+
+    it "proxies resolution vaule in array" do
+      deferred = When::Deferred.new
+      d = When.all([deferred.promise])
+      results = nil
+      d.callback { |res| results = res }
+
+      deferred.resolve(42)
+      assert_equal [42], results
+    end
+
+    it "orders results like input" do
+      deferred1 = When::Deferred.new
+      deferred2 = When::Deferred.new
+      d = When.all([deferred1.promise, deferred2.promise])
+      results = nil
+      d.callback { |res| results = res }
+
+      deferred2.resolve(42)
+      deferred1.resolve(13)
+      assert_equal [13, 42], results
+    end
+  end
+end

data/test/dolt/git/repository_test.rb

@@ -17,6 +17,7 @@
 #++
 require "test_helper"
 require "dolt/git/repository"
+require "time"
 
 describe Dolt::Git::Repository do
   include EM::MiniTest::Spec
@@ -57,4 +58,93 @@ describe Dolt::Git::Repository do
       wait!
     end
   end
+
+  describe "#tree_history" do
+    before { @repository = Dolt::Git::Repository.new(".") }
+
+    it "returns deferrable" do
+      deferrable = @repository.tree_history("master", "")
+      assert deferrable.respond_to?(:callback)
+      assert deferrable.respond_to?(:errback)
+    end
+
+    it "fails if path is not a tree" do
+      deferrable = @repository.tree_history("master", "Gemfile")
+      deferrable.errback do |err|
+        assert_match /not a tree/, err.message
+        done!
+      end
+      wait!
+    end
+
+    it "fails if path does not exist in ref" do
+      deferrable = @repository.tree_history("26139a3", "test")
+      deferrable.errback do |err|
+        assert_match /does not exist/, err.message
+        done!
+      end
+      wait!
+    end
+
+    it "yields tree with history" do
+      promise = @repository.tree_history("48ffbf7", "")
+
+      promise.callback do |log|
+        assert_equal 11, log.length
+        expected = {
+          :type => :blob,
+          :oid => "e90021f89616ddf86855d05337c188408d3b417e",
+          :filemode => 33188,
+          :name => ".gitmodules",
+          :history => [{
+            :oid => "906d67b4f3e5de7364ba9b57d174d8998d53ced6",
+            :author => { :name => "Christian Johansen",
+                         :email => "christian@cjohansen.no" },
+            :summary => "Working Moron server for viewing blobs",
+            :date => Time.parse("Mon Sep 10 15:07:39 +0200 2012"),
+            :message => ""
+          }]
+        }
+
+        assert_equal expected, log[0]
+        done!
+      end
+
+      promise.errback do |err|
+        puts "FAILED! #{err.inspect}"
+      end
+
+      wait!
+    end
+
+    it "yields nested tree with history" do
+      promise = @repository.tree_history("48ffbf7", "lib")
+
+      promise.callback do |log|
+        expected = [{
+          :type => :tree,
+          :oid => "58f84405b588699b24c619aa4cd83669c5623f88",
+          :filemode => 16384,
+          :name => "dolt",
+          :history => [{
+            :oid => "8ab4f8c42511f727244a02aeee04824891610bbd",
+            :author => { :name => "Christian Johansen",
+                         :email => "christian@gitorious.com" },
+            :summary => "New version",
+            :date => Time.parse("Mon Oct 1 16:34:00 +0200 2012"),
+            :message => ""
+          }]
+        }]
+
+        assert_equal expected, log
+        done!
+      end
+
+      promise.errback do |err|
+        puts "FAILED! #{err.inspect}"
+      end
+
+      wait!
+    end
+  end
 end