libdolt 0.6.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    libdolt (0.6.0)
+      em_pessimistic (~> 0.1)
+      em_rugged (~> 0.1.2)
+      eventmachine (~> 1.0)
+      htmlentities (~> 4.3)
+      json (~> 1.7)
+      makeup (~> 0)
+      mime-types (~> 1.19)
+      tzinfo (~> 0.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    em-minitest-spec (1.1.1)
+      eventmachine
+    em_pessimistic (0.1.2)
+      eventmachine (~> 1.0)
+    em_rugged (0.1.3)
+      eventmachine (~> 1.0)
+      rugged (= 0.17.0.b6)
+    eventmachine (1.0.0)
+    github-markup (0.7.4)
+    htmlentities (4.3.1)
+    json (1.7.5)
+    makeup (0.1.1)
+      github-markup (~> 0.7)
+      htmlentities (~> 4.3)
+      pygments.rb (~> 0.2)
+    mime-types (1.19)
+    minitest (2.12.1)
+    posix-spawn (0.3.6)
+    pygments.rb (0.3.1)
+      posix-spawn (~> 0.3.6)
+      yajl-ruby (~> 1.1.0)
+    rake (0.9.2.2)
+    redcarpet (2.1.1)
+    rugged (0.17.0.b6)
+    tilt (1.3.3)
+    tiltout (1.0.0)
+      tilt (~> 1.3)
+    tzinfo (0.3.33)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-minitest-spec (~> 1.1)
+  libdolt!
+  minitest (~> 2.0)
+  rake (~> 0.9)
+  redcarpet
+  tiltout (~> 1)

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake/testtask"
+require "bundler/gem_tasks"
+
+Rake::TestTask.new("test") do |test|
+  test.libs << "test"
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end
+
+task :default => :test

data/Readme.md

@@ -0,0 +1,99 @@
+# Dolt - The Git project browser
+
+Dolt is a stand-alone Git repository browser. It can be used to explore repos in
+your browser of choice and features syntax highlighting with
+[Pygments](http://pygments.org/),
+[Markdown](http://daringfireball.net/projects/markdown/)/[org-mode](http://orgmode.org/)/[+++](https://github.com/github/markup/)
+rendering, commit log and blame.
+
+Dolt is also a library, designed to render Git trees, blobs, commit log and
+blame. It can render said views with or without a layout, or you can provide
+your own templates (through [Tilt](https://github.com/rtomayko/tilt/)). You can
+also provide your own rendering implementation to render other formats than
+templates outputting HTML.
+
+Dolt is the implementation of the next generation repo browser to be used in the
+[Gitorious](http://gitorious.org) software.
+
+## Installing Dolt
+
+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
+yet released, so you have to build it yourself.
+[See em-rugged instructions](http://github.com/cjohansen/em-rugged).
+
+### Systems using apt (Debian/Ubuntu, others)
+
+    # 1) Install Ruby (skip if you already have Ruby installed)
+    sudo apt-get install ruby
+
+    # 2) Install Python development files
+    sudo apt-get install python-dev
+
+    # 3) Install dolt. This may or may not require the use of sudo, depending on
+    #    how you installed Ruby. This step assumes that you already built and
+    #    installed em-rugged as explained above.
+    sudo gem install dolt
+
+### Systems using yum (Fedora/CentOS/RedHat, others)
+
+    # 1) Install Ruby (skip if you already have Ruby installed)
+    sudo yum install ruby
+
+    # 2) Install Python development files
+    sudo yum install python-devel
+
+    # 3) Install dolt. This may or may not require the use of sudo, depending on
+    #    how you installed Ruby. This step assumes that you already built and
+    #    installed em-rugged as explained above.
+    sudo gem install dolt
+
+# The Dolt CLI
+
+The `dolt` library installs a CLI that can be used to quickly browse either a
+single (typically the current) repository, or multiple repositories.
+
+## Browsing a single repository
+
+In a git repository, issue the following command:
+
+    $ dolt .
+
+Then open a browser at [http://localhost:3000](http://localhost:3000). You will
+be redirected to the root tree, and can browse the repository. To view trees and
+blobs at specific refs, use the URL. A branch/tag selector will be added later.
+
+## Browsing multiple repositories
+
+The idea is that eventually, `dolt` should be able to serve up all Git
+repositories managed by your Gitorious server. It does not yet do that, because
+there currently is no "repository resolver" that understands the hashed paths
+Gitorious uses.
+
+Meanwhile, if you have a directory that contains multiple git repositories, you
+can browse all of them through the same process by doing:
+
+    $ dolt /path/to/repos
+
+Now [http://localhost:3000/repo](http://localhost:3000/repo) will allow you to
+browse the `/path/repos/repo` repository. As `dolt` matures, there will be a
+listing of all repositories and more.
+
+## Markup rendering
+
+Dolt uses the [``GitHub::Markup``](https://github.com/github/markup/) library to
+render certain markup formats as HTML. Dolt does not have a hard dependency on
+any of the required gems to actually render markups, so see the
+[``GitHub::Markup`` docs](https://github.com/github/markup/) for information on
+what and how to install support for various languages.
+
+# License
+
+Dolt is free software licensed under the
+[GNU Affero General Public License (AGPL)](http://www.gnu.org/licenses/agpl-3.0.html).
+Dolt is developed as part of the Gitorious project.

data/lib/libdolt/async/when.rb

@@ -0,0 +1,128 @@
+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/libdolt/disk_repo_resolver.rb

@@ -0,0 +1,39 @@
+# 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 "libdolt/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/libdolt/git/blame.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 "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/libdolt/git/commit.rb

@@ -0,0 +1,73 @@
+# 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/libdolt/git/repository.rb

@@ -0,0 +1,139 @@
+# 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 "libdolt/git/blame"
+require "libdolt/git/commit"
+require "libdolt/git/submodule"
+require "libdolt/git/tree"
+require "libdolt/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

data/lib/libdolt/git/submodule.rb

@@ -0,0 +1,35 @@
+# 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/>.
+#++
+
+module Dolt
+  module Git
+    class Submodule
+      def self.parse_config(config)
+        config.split("\n").inject([]) do |modules, line|
+          if line =~ /\[submodule ".*"\]/
+            modules << {}
+          else
+            _, key, val = *line.match(/\s([^\s]+) = ([^\s]+)/)
+            modules.last[key.to_sym] = val
+          end
+          modules
+        end
+      end
+    end
+  end
+end