libdolt 0.15.0 → 0.16.0

data/Gemfile.lock

@@ -2,36 +2,25 @@ PATH
   remote: .
   specs:
     libdolt (0.15.0)
-      em_pessimistic (~> 0.1)
-      em_rugged (~> 0.3)
-      eventmachine (~> 1.0)
       htmlentities (~> 4.3)
       json (~> 1.7)
       makeup (~> 0.2)
       mime-types (~> 1.19)
+      rugged (= 0.17.0.b6)
       tzinfo (~> 0.3)
-      when (~> 0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    em-minitest-spec (1.1.1)
-      eventmachine
-    em_pessimistic (0.1.2)
-      eventmachine (~> 1.0)
-    em_rugged (0.3.0)
-      eventmachine (~> 1.0)
-      rugged (= 0.17.0.b6)
-    eventmachine (1.0.0)
     github-markup (0.7.5)
     htmlentities (4.3.1)
-    json (1.7.6)
+    json (1.7.7)
     makeup (0.3.0)
       github-markup (~> 0.7)
       htmlentities (~> 4.3)
       pygments.rb (~> 0.2)
     metaclass (0.0.1)
-    mime-types (1.19)
+    mime-types (1.21)
     minitest (2.12.1)
     mocha (0.13.1)
       metaclass (~> 0.0.1)
@@ -46,14 +35,12 @@ GEM
     tiltout (1.4.0)
       tilt (~> 1.3)
     tzinfo (0.3.35)
-    when (0.1.0)
     yajl-ruby (1.1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  em-minitest-spec (~> 1.1)
   libdolt!
   minitest (~> 2.0)
   mocha

data/Readme.md

@@ -25,9 +25,8 @@ 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) through
-[em-rugged](http://gitorious.org/gitorious/em-rugged) for Git access where
-feasible. Currently, ``EMRugged`` relies on a version of `Rugged` that is not
+[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).
 

data/lib/libdolt/git/archiver.rb

@@ -15,21 +15,14 @@
 #   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 "when"
-require "eventmachine"
-require "em_pessimistic"
 require "fileutils"
+require "shellwords"
+require "libdolt/git"
 
 module Dolt
   module Git
     class Archiver
       def initialize(work_dir, cache_dir)
-        # A hash of currently processing archiving jobs. It contains tuples of
-        # "#{repo.id}-#{oid}-#{format}" => promises representing the eventual
-        # completion of archiving tasks. When an archiving task is completed,
-        # its promise is removed from the hash. Previously generated tarballs
-        # can be found on disk.
-        @processing = {}
         @work_dir = work_dir
         @cache_dir = cache_dir
       end
@@ -42,40 +35,23 @@ module Dolt
       #   format - A symbol. If it is not :zip, tar.gz is assumed.
       def archive(repo, oid, format = :tgz)
         filename = cache_path(repo, oid, format)
-        return When.resolve(filename) if File.exists?(filename)
-        pending = pending_process(repo, oid, format)
-        return pending if pending
-        start_process(repo, oid, format)
+        return filename if File.exists?(filename)
+        archive_repo(repo, oid, format)
       end
 
       private
-      def process_id(repo, oid, format)
-        "#{repo.id}-#{oid}-#{ext(format)}"
-      end
-
-      def pending_process(repo, oid, format)
-        @processing[process_id(repo, oid, format)]
-      end
-
-      def start_process(repo, oid, format)
-        @processing[process_id(repo, oid, format)] = When.defer do |d|
-          p = EMPessimistic::DeferrableChildProcess.open(cmd(repo, oid, format))
-
-          p.callback do |output, status|
-            filename = cache_path(repo, oid, format)
-            FileUtils.mv(work_path(repo, oid, format), filename)
-            d.resolve(filename)
-          end
-
-          p.errback do |output, status|
-            d.reject(Exception.new(output))
-          end
-        end
+      def archive_repo(repo, oid, format)
+        process = Dolt::Git.shell(cmd(repo, oid, format))
+        raise process.exception if !process.success?
+        filename = cache_path(repo, oid, format)
+        FileUtils.mv(work_path(repo, oid, format), filename)
+        filename
       end
 
       def cmd(repository, oid, format)
         path_segment = repository.path_segment.gsub(/\//, "-")
-        cmd = "sh -c 'git --git-dir #{repository.full_repository_path} archive "
+        git = Dolt::Git.binary
+        cmd = "sh -c '#{git} --git-dir #{repository.full_repository_path} archive "
         cmd += "--prefix='#{u(path_segment)}/' --format="
         wpath = u(work_path(repository, oid, format))
         cmd + (format.to_s == "zip" ? "zip #{u(oid)} > #{wpath}" : "tar #{u(oid)} | gzip -m > #{wpath}") + "'"
@@ -90,17 +66,16 @@ module Dolt
       end
 
       def basename(repository, oid, format)
-        path_segment = repository.path_segment.gsub(/\//, "-")
-        "#{path_segment}-#{oid}.#{ext(format)}"
+        path_segment = "#{repository.path_segment}-#{oid}".gsub(/\//, "-")
+        "#{path_segment}.#{ext(format)}"
       end
 
       def ext(format)
         format.to_s == "zip" ? "zip" : "tar.gz"
       end
 
-      # Unquote a string by stripping off any single or double quotes
       def u(string)
-        string.gsub("'", '').gsub('"', '')
+        Shellwords.escape(string)
       end
     end
   end

data/lib/libdolt/git/blame.rb

@@ -19,6 +19,8 @@ require "tzinfo"
 
 module Dolt
   module Git
+    class InvalidBlameFormat < Exception; end
+
     class Blame
       attr_reader :chunks
 
@@ -53,6 +55,8 @@ module Dolt
           end
 
           chunks
+        rescue Exception => error
+          raise InvalidBlameFormat.new("Failed parsing Procelain: #{error.message}")
         end
 
         def is_header?(line)

data/lib/libdolt/git/process.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+#--
+#   Copyright (C) 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/>.
+#++
+
+module Dolt
+  module Git
+    class Process
+      attr_reader :stdin, :stdout, :stderr
+
+      def initialize(stdin, stdout, stderr, process_status)
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+        @process_status = process_status
+      end
+
+      def success?
+        @process_status.success?
+      end
+
+      def exit_code
+        @process_status.exitstatus
+      end
+
+      def exception
+        Exception.new(stderr.read)
+      end
+    end
+  end
+end

data/lib/libdolt/git/repository.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 #--
-#   Copyright (C) 2012 Gitorious AS
+#   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
@@ -15,53 +15,45 @@
 #   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/repository"
-require "em_pessimistic/deferrable_child_process"
+require "rugged"
+require "libdolt/git"
 require "libdolt/git/blame"
 require "libdolt/git/commit"
 require "libdolt/git/submodule"
 require "libdolt/git/tree"
-require "when"
 
 module Dolt
   module Git
-    class Repository < EMRugged::Repository
-      def submodules(ref)
-        d = When.defer
-        gm = rev_parse("#{ref}:.gitmodules")
-        gm.callback do |config|
-          d.resolve(Dolt::Git::Submodule.parse_config(config.content))
-        end
-        # Fails if .gitmodules cannot be found, which means no submodules
-        gm.errback { |err| d.resolve([]) }
-        d
+    class Repository
+      def initialize(root)
+        @repo = Rugged::Repository.new(root)
       end
 
-      def tree_entry(ref, path)
-        When.defer do |d|
-          rp = rev_parse("#{ref}:#{path}")
-          rp.callback { |object| annotate_tree(d, ref, path, object) }
-          rp.errback { |err| d.reject(err) }
-        end
+      def bare?; @repo.bare?; end
+      def path; @repo.path; end
+      def rev_parse(*args); @repo.rev_parse(*args); end
+
+      def submodules(ref)
+        config = rev_parse("#{ref}:.gitmodules")
+        Dolt::Git::Submodule.parse_config(config.content)
+      rescue Rugged::IndexerError => err
+        # Raised if .gitmodules cannot be found, which means no submodules
+        []
       end
 
       def tree(ref, path)
-        When.defer do |d|
-          rp = rev_parse("#{ref}:#{path}")
-          rp.callback do |object|
-            if !object.is_a?(Rugged::Tree)
-              next d.reject(StandardError.new("Not a tree"))
-            end
-            annotate_tree(d, ref, path, object)
-          end
-          rp.errback { |err| d.reject(err) }
-        end
+        object = rev_parse("#{ref}:#{path}")
+        raise StandardError.new("Not a tree") if !object.is_a?(Rugged::Tree)
+        annotate_tree(ref, path, object)
       end
 
-      def blame(ref, path)
-        deferred_method("blame -l -t -p #{ref} -- #{path}") do |output, s|
-          Dolt::Git::Blame.parse_porcelain(output)
-        end
+      def tree_entry(ref, path)
+        annotate_tree(ref, path, rev_parse("#{ref}:#{path}"))
+      end
+
+      def blame(ref, blob_path)
+        process = Dolt::Git.git(path, "blame -l -t -p #{ref} -- #{blob_path}")
+        Dolt::Git::Blame.parse_porcelain(process.stdout.read)
       end
 
       def log(ref, path, limit)
@@ -69,98 +61,61 @@ module Dolt
       end
 
       def tree_history(ref, path, limit = 1)
-        When.defer do |d|
-          rp = rev_parse("#{ref}:#{path}")
-          rp.errback { |err| d.reject(err) }
-          rp.callback do |tree|
-            if tree.class != Rugged::Tree
-              message = "#{ref}:#{path} is not a tree (#{tree.class.to_s})"
-              next d.reject(Exception.new(message))
-            end
+        tree = rev_parse("#{ref}:#{path}")
 
-            building = build_history(path || "./", ref, tree, limit)
-            building.callback { |history| d.resolve(history) }
-            building.errback { |err| d.reject(err) }
-          end
+        if tree.class != Rugged::Tree
+          message = "#{ref}:#{path} is not a tree (#{tree.class.to_s})"
+          raise Exception.new(message)
         end
+
+        annotate_history(path || "./", ref, tree, limit)
       end
 
       def readme(ref)
-        When.defer do |d|
-          t = self.tree(ref, "")
-          t.callback do |tree|
-            d.resolve(tree.entries.select do |e|
-                        e[:type] == :blob && e[:name].match(/readme/i)
-                      end)
-          end
-          t.errback { |err| d.resolve([]) }
+        tree(ref, "").entries.select do |e|
+          e[:type] == :blob && e[:name].match(/readme/i)
         end
+      rescue Exception => err
+        []
       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
+        process = Dolt::Git.git(path, "log -n #{limit} #{ref} -- #{entry}")
+        Dolt::Git::Commit.parse_log(process.stdout.read)
       end
 
-      def build_history(path, ref, entries, limit)
-        d = When.defer
+      def annotate_history(path, ref, entries, limit)
         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.reject(e) }
-        progress.callback do |history|
-          d.resolve(entries.map { |e| e.merge({ :history => history.shift }) })
+        entries.map do |e|
+          e.merge(:history => entry_history(ref, resolve.call(e[:name]), limit))
         end
-        d
       end
 
-      def annotate_tree(d, ref, path, object)
+      def annotate_tree(ref, path, object)
         if object.class.to_s.match(/Blob/) || !object.find { |e| e[:type].nil? }
-          return d.resolve(object)
+          return object
         end
 
-        annotate_submodules(d, ref, path, object)
+        annotate_submodules(ref, path, object)
       end
 
-      def annotate_submodules(deferrable, ref, path, tree)
-        submodules(ref).callback do |submodules|
-          entries = tree.entries.map do |entry|
-            if entry[:type].nil?
-              mod = path == "" ? entry[:name] : File.join(path, entry[:name])
-              meta = submodules.find { |s| s[:path] == mod }
-              if meta
-                entry[:type] = :submodule
-                entry[:url] = meta[:url]
-              end
+      def annotate_submodules(ref, path, tree)
+        modules = submodules(ref)
+
+        entries = tree.entries.map do |entry|
+          if entry[:type].nil?
+            mod = path == "" ? entry[:name] : File.join(path, entry[:name])
+            meta = modules.find { |s| s[:path] == mod }
+            if meta
+              entry[:type] = :submodule
+              entry[:url] = meta[:url]
             end
-            entry
           end
-
-          deferrable.resolve(Dolt::Git::Tree.new(tree.oid, entries))
-        end
-      end
-
-      def deferred_method(cmd, &block)
-        d = When.defer
-        cmd = git(cmd)
-        p = EMPessimistic::DeferrableChildProcess.open(cmd)
-
-        p.callback do |output, status|
-          d.resolve(block.call(output, status))
+          entry
         end
 
-        p.errback do |stderr, status|
-          d.reject(stderr)
-        end
-
-        d
-      end
-
-      def git(cmd)
-        "git --git-dir #{path} #{cmd}"
+        Dolt::Git::Tree.new(tree.oid, entries)
       end
     end
   end

data/lib/libdolt/git.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+#--
+#   Copyright (C) 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 "open3"
+require "libdolt/git/process"
+require "shellwords"
+
+module Dolt
+  module Git
+    def self.shell(command)
+      stdin, stdout, stderr = Open3.popen3(command)
+      Dolt::Git::Process.new(stdin, stdout, stderr, $?)
+    end
+
+    def self.git(git_dir, command)
+      args = Shellwords.join(command.split(" "))
+      shell("#{binary} --git-dir #{git_dir} #{args}")
+    end
+
+    def self.binary
+      @binary ||= "git"
+    end
+
+    def self.binary=(path)
+      @binary = path
+    end
+  end
+end

data/lib/libdolt/repo_actions.rb

@@ -28,50 +28,43 @@ module Dolt
       @archiver = archiver
     end
 
-    def blob(repo, ref, path, &block)
-      repo_action(repo, ref, path, :blob, :rev_parse, "#{ref}:#{path}", &block)
+    def blob(repo, ref, path)
+      repo_action(repo, ref, path, :blob, :rev_parse, "#{ref}:#{path}")
     end
 
-    def tree(repo, ref, path, &block)
-      repo_action(repo, ref, path, :tree, :tree, ref, path, &block)
+    def tree(repo, ref, path)
+      repo_action(repo, ref, path, :tree, :tree, ref, path)
     end
 
-    def tree_entry(repo, ref, path, &block)
+    def tree_entry(repo, ref, path)
       repository = resolve_repository(repo)
-      d = repository.tree_entry(ref, path)
-      d.callback do |result|
-        key = result.class.to_s.match(/Blob/) ? :blob : :tree
-        block.call(nil, tpl_data(repository, ref, path, { key => result, :type => key }))
-      end
-      d.errback { |err| block.call(err, nil) }
+      result = repository.tree_entry(ref, path)
+      key = result.class.to_s.match(/Blob/) ? :blob : :tree
+      tpl_data(repository, ref, path, { key => result, :type => key })
     end
 
-    def blame(repo, ref, path, &block)
-      repo_action(repo, ref, path, :blame, :blame, ref, path, &block)
+    def blame(repo, ref, path)
+      repo_action(repo, ref, path, :blame, :blame, ref, path)
     end
 
-    def history(repo, ref, path, count, &block)
-      repo_action(repo, ref, path, :commits, :log, ref, path, count, &block)
+    def history(repo, ref, path, count)
+      repo_action(repo, ref, path, :commits, :log, ref, path, count)
     end
 
-    def refs(repo, &block)
+    def refs(repo)
       repository = resolve_repository(repo)
-      d = repository.refs
-      d.callback do |refs|
-        names = refs.map(&:name)
-        block.call(nil, {
-                     :tags => expand_refs(repository, names, :tags),
-                     :heads => expand_refs(repository, names, :heads)
-                   }.merge(repository.to_hash))
-      end
-      d.errback { |err| block.call(err, nil) }
+      names = repository.refs.map(&:name)
+      {
+        :tags => expand_refs(repository, names, :tags),
+        :heads => expand_refs(repository, names, :heads)
+      }.merge(repository.to_hash)
     end
 
-    def tree_history(repo, ref, path, count, &block)
-      repo_action(repo, ref, path, :tree, :tree_history, ref, path, count, &block)
+    def tree_history(repo, ref, path, count)
+      repo_action(repo, ref, path, :tree, :tree_history, ref, path, count)
     end
 
-    def archive(repo, ref, format, &block)
+    def archive(repo, ref, format)
       repository = resolve_repository(repo)
       d = @archiver.archive(repository, ref, format)
       d.callback { |filename| block.call(nil, filename) }
@@ -87,19 +80,18 @@ module Dolt
     end
 
     def rev_parse_oid(repo, ref)
-      resolve_repository(repo).rev_parse_oid_sync(ref)
+      resolve_repository(repo).rev_parse_oid(ref)
     end
 
     private
     def repo_resolver; @repo_resolver; end
 
-    def repo_action(repo, ref, path, data, method, *args, &block)
+    def repo_action(repo, ref, path, data, method, *args)
       repository = resolve_repository(repo)
-      d = repository.send(method, *args)
-      d.callback do |result|
-        block.call(nil, tpl_data(repository, ref, path, { data => result }))
-      end
-      d.errback { |err| block.call(err, nil) }
+
+      tpl_data(repository, ref, path, {
+          data => repository.send(method, *args)
+        })
     end
 
     def tpl_data(repo, ref, path, locals = {})
@@ -109,7 +101,7 @@ module Dolt
 
     def expand_refs(repository, names, type)
       names.select { |n| n =~ /#{type}/ }.map do |n|
-        [n.sub(/^refs\/#{type}\//, ""), repository.rev_parse_oid_sync(n)]
+        [n.sub(/^refs\/#{type}\//, ""), repository.rev_parse_oid(n)]
       end
     end
   end

data/lib/libdolt/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Dolt
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/libdolt.rb

@@ -1,7 +1,6 @@
-
 # encoding: utf-8
 #--
-#   Copyright (C) 2012 Gitorious AS
+#   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
@@ -16,7 +15,6 @@
 #   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 "libdolt/version"
 require "libdolt/disk_repo_resolver"
 require "libdolt/gitorious_repo_resolver"

data/libdolt.gemspec

@@ -13,10 +13,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "libdolt"
 
-  s.add_dependency "eventmachine", "~>1.0"
-  s.add_dependency "when", "~>0"
-  s.add_dependency "em_pessimistic", "~>0.1"
-  s.add_dependency "em_rugged", "~> 0.3"
+  s.add_dependency "rugged", "0.17.0.b6"
   s.add_dependency "tzinfo", "~> 0.3"
   s.add_dependency "makeup", "~>0.2"
   s.add_dependency "htmlentities", "~> 4.3"
@@ -24,7 +21,6 @@ Gem::Specification.new do |s|
   s.add_dependency "mime-types", "~> 1.19"
 
   s.add_development_dependency "minitest", "~> 2.0"
-  s.add_development_dependency "em-minitest-spec", "~> 1.1"
   s.add_development_dependency "rake", "~> 0.9"
   s.add_development_dependency "redcarpet", "2.2.0"
   s.add_development_dependency "tiltout", "~>1.4"