dolt 0.5.1 → 0.6.0

data/lib/dolt/async/when.rb

@@ -1,128 +0,0 @@
-require "eventmachine"
-
-module When
-  class Promise
-    def initialize(deferred = EM::DefaultDeferrable.new)
-      @deferred = deferred
-    end
-
-    def callback(&block)
-      @deferred.callback(&block)
-      self
-    end
-
-    def errback(&block)
-      @deferred.errback(&block)
-      self
-    end
-  end
-
-  class Resolver
-    def initialize(deferred = EM::DefaultDeferrable.new)
-      @deferred = deferred
-      @resolved = false
-    end
-
-    def resolve(*args)
-      mark_resolved
-      @deferred.succeed(*args)
-    end
-
-    def reject(*args)
-      mark_resolved
-      @deferred.fail(*args)
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    private
-    def mark_resolved
-      raise StandardError.new("Already resolved") if @resolved
-      @resolved = true
-    end
-  end
-
-  class Deferred
-    attr_reader :resolver, :promise
-
-    def initialize
-      deferred = EM::DefaultDeferrable.new
-      @resolver = Resolver.new(deferred)
-      @promise = Promise.new(deferred)
-    end
-
-    def resolve(*args)
-      @resolver.resolve(*args)
-    end
-
-    def reject(*args)
-      @resolver.reject(*args)
-    end
-
-    def callback(&block)
-      @promise.callback(&block)
-    end
-
-    def errback(&block)
-      @promise.errback(&block)
-    end
-
-    def resolved?
-      @resolver.resolved?
-    end
-
-    def self.resolved(value)
-      d = self.new
-      d.resolve(value)
-      d
-    end
-
-    def self.rejected(value)
-      d = self.new
-      d.reject(value)
-      d
-    end
-  end
-
-  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/disk_repo_resolver.rb

@@ -1,39 +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/>.
-#++
-require "dolt/git/repository"
-
-module Dolt
-  class DiskRepoResolver
-    def initialize(root)
-      @root = root
-    end
-
-    def resolve(repo)
-      Dolt::Git::Repository.new(File.join(root, repo))
-    end
-
-    def all
-      (Dir.entries(root).select do |e|
-         File.exists?(File.join(root, e, ".git"))
-       end).sort
-    end
-
-    private
-    def root; @root; end
-  end
-end

data/lib/dolt/git/blame.rb

@@ -1,112 +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/>.
-#++
-require "tzinfo"
-
-module Dolt
-  module Git
-    class Blame
-      attr_reader :chunks
-
-      def initialize(chunks)
-        @chunks = chunks
-      end
-
-      def self.parse_porcelain(output)
-        self.new(Dolt::Git::Blame::PorcelainParser.new(output).parse)
-      end
-
-      class PorcelainParser
-        def initialize(output)
-          @output = output
-          @commits = {}
-        end
-
-        def parse
-          lines = @output.split("\n")
-          chunks = []
-
-          while lines.length > 0
-            chunk = extract_header(lines)
-            affected_lines = extract_lines(lines, chunk[:num_lines])
-
-            if chunks.last && chunk[:oid] == chunks.last[:oid]
-              chunks.last[:lines].concat(affected_lines)
-            else
-              chunk[:lines] = affected_lines
-              chunks << chunk
-            end
-          end
-
-          chunks
-        end
-
-        def is_header?(line)
-          line =~ /^[0-9a-f]{40} \d+ \d+ \d+$/
-        end
-
-        def extract_header(lines)
-          header = lines.shift
-          pieces = header.scan(/^([0-9a-f]{40}) (\d+) (\d+) (\d+)$/).first
-          header = { :oid => pieces.first, :num_lines => pieces[3].to_i }
-
-          if lines.first =~ /^author/
-            header[:author] = extract_hash(lines, :author)
-            header[:committer] = extract_hash(lines, :committer)
-            header[:summary] = extract(lines, "summary")
-            throwaway = lines.shift until throwaway =~ /^filename/
-            @commits[header[:oid]] = header
-          else
-            header[:author] = @commits[header[:oid]][:author]
-            header[:committer] = @commits[header[:oid]][:committer]
-            header[:summary] = @commits[header[:oid]][:summary]
-          end
-
-          header
-        end
-
-        def extract_lines(lines, num)
-          extracted = []
-
-          num.times do
-            if extracted.length > 0
-              line = lines.shift # Header for next line
-            end
-
-            content = lines.shift # Actual content
-            extracted.push(content[1..content.length]) # 8 spaces padding
-          end
-
-          extracted
-        end
-
-        def extract_hash(lines, type)
-          {
-            :name => extract(lines, "#{type}"),
-            :mail => extract(lines, "#{type}-mail").gsub(/[<>]/, ""),
-            :time => (Time.at(extract(lines, "#{type}-time").to_i) +
-                      Time.zone_offset(extract(lines, "#{type}-tz")))
-          }
-        end
-
-        def extract(lines, thing)
-          lines.shift.split("#{thing} ")[1]
-        end
-      end
-    end
-  end
-end

data/lib/dolt/git/commit.rb

@@ -1,73 +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/>.
-#++
-require "time"
-
-module Dolt
-  module Git
-    class Commit
-      def self.parse_log(log)
-        commits = []
-        lines = log.split("\n")
-        commits << extract_commit(lines) while lines.length > 0
-        commits
-      end
-
-      def self.extract_commit(lines)
-        commit = { :oid => lines.shift.split(" ")[1] }
-        while (line = lines.shift) != ""
-          pieces = line.split(": ")
-          extract_property(commit, pieces[0], pieces[1])
-        end
-
-        commit[:summary] = extract_commit_summary(lines)
-        commit[:message] = extract_commit_message(lines)
-        commit
-      end
-
-      def self.extract_property(hash, name, value)
-        key = name.downcase.to_sym
-
-        case key
-        when :author
-          pieces = value.match(/(.*)\s<(.*)>/)
-          value = { :name => pieces[1], :email => pieces[2] }
-        when :date
-          value = Time.parse(value)
-        end
-
-        hash[key] = value
-      end
-
-      def self.extract_commit_summary(lines)
-        summary = lines.shift
-        lines.shift if lines.first == ""
-        summary.sub(/^    /, "")
-      end
-
-      def self.extract_commit_message(lines)
-        message = ""
-
-        while !lines.first.nil? && lines.first !~ /^commit [a-z0-9]{40}$/
-          message << lines.shift
-        end
-
-        message
-      end
-    end
-  end
-end

data/lib/dolt/git/repository.rb

@@ -1,139 +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/>.
-#++
-require "em_rugged/repository"
-require "em_pessimistic/deferrable_child_process"
-require "em/deferrable"
-require "dolt/git/blame"
-require "dolt/git/commit"
-require "dolt/git/submodule"
-require "dolt/git/tree"
-require "dolt/async/when"
-
-module Dolt
-  module Git
-    class Repository < EMRugged::Repository
-      def submodules(ref)
-        d = EventMachine::DefaultDeferrable.new
-        gm = rev_parse("#{ref}:.gitmodules")
-        gm.callback do |config|
-          d.succeed(Dolt::Git::Submodule.parse_config(config.content))
-        end
-        # Fails if .gitmodules cannot be found, which means no submodules
-        gm.errback { |err| d.succeed([]) }
-        d
-      end
-
-      def tree(ref, path)
-        d = EventMachine::DefaultDeferrable.new
-        rp = rev_parse("#{ref}:#{path}")
-        rp.callback do |tree|
-          break d.fail(StandardError.new("Not a tree")) unless tree.is_a?(Rugged::Tree)
-          break d.succeed(tree) if !tree.find { |e| e[:type].nil? }
-          annotate_submodules(ref, path, d, tree)
-        end
-        rp.errback { |err| d.fail(err) }
-        d
-      end
-
-      def blame(ref, path)
-        deferred_method("blame -l -t -p #{ref} #{path}") do |output, s|
-          Dolt::Git::Blame.parse_porcelain(output)
-        end
-      end
-
-      def log(ref, path, limit)
-        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 annotate_submodules(ref, path, deferrable, 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
-            end
-            entry
-          end
-
-          deferrable.succeed(Dolt::Git::Tree.new(tree.oid, entries))
-        end
-      end
-
-      def deferred_method(cmd, &block)
-        d = EventMachine::DefaultDeferrable.new
-        cmd = git(cmd)
-        p = EMPessimistic::DeferrableChildProcess.open(cmd)
-
-        p.callback do |output, status|
-          d.succeed(block.call(output, status))
-        end
-
-        p.errback do |stderr, status|
-          d.fail(stderr)
-        end
-
-        d
-      end
-
-      def git(cmd)
-        "git --git-dir #{subject.path} #{cmd}"
-      end
-    end
-  end
-end