bob 0.1 → 0.4.0

data/lib/bob/scm.rb

@@ -5,19 +5,11 @@ module Bob
     autoload :Git, "bob/scm/git"
     autoload :Svn, "bob/scm/svn"
 
-    class CantRunCommand < RuntimeError; end
+    class Error < StandardError; end
 
-    # Factory to return appropriate SCM instances (according to repository kind)
-    def self.new(kind, uri, branch)
-      class_for(kind).new(uri, branch)
+    # Factory to return appropriate SCM instances
+    def self.new(scm, uri, branch)
+      const_get(scm.to_s.capitalize).new(uri, branch)
     end
-
-    # A copy of Inflector.camelize, from ActiveSupport. It will convert
-    # string to UpperCamelCase.
-    def self.class_for(kind)
-      class_name = kind.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      const_get(class_name)
-    end
-    private_class_method :class_for
   end
 end

data/lib/bob/scm/abstract.rb

@@ -4,46 +4,60 @@ module Bob
       attr_reader :uri, :branch
 
       def initialize(uri, branch)
-        @uri = Addressable::URI.parse(uri)
+        @uri    = Addressable::URI.parse(uri)
         @branch = branch
       end
 
-      # Checkout the code into <tt>working_dir</tt> at the specified revision and
-      # call the passed block
-      def with_commit(commit_id)
-        update_code
-        checkout(commit_id)
-        yield
+      # Checkout the code at the specified <tt>commit</tt> and call the
+      # passed block.
+      def with_commit(commit)
+        commit = resolve(commit)
+        checkout(commit)
+        yield(commit)
       end
 
-      # Directory where the code will be checked out. Make sure the user running Bob is
-      # allowed to write to this directory (or you'll get a <tt>Errno::EACCESS</tt>)
-      def working_dir
-        @working_dir ||= "#{Bob.directory}/#{path_from_uri}".tap do |path|
-          FileUtils.mkdir_p path
-        end
-      end
-
-      # Get some information about the specified commit. Returns a hash with:
-      #
-      # [<tt>:author</tt>]       Commit author's name and email
-      # [<tt>:message</tt>]      Commit message
-      # [<tt>:committed_at</tt>] Commit date (as a <tt>Time</tt> object)
-      def info(commit_id)
-        raise NotImplementedError
+      # Directory where the code will be checked out for the given
+      # <tt>commit</tt>.
+      def dir_for(commit)
+        Bob.directory.join(path, resolve(commit))
       end
 
       protected
 
-      def run(command)
-        command = "(cd #{working_dir} && #{command} &>/dev/null)"
-        Bob.logger.debug command
-        system(command) || raise(CantRunCommand, "Couldn't run SCM command `#{command}`")
+      # Get some information about the specified <tt>commit</tt>.
+      # Returns a hash with:
+      #
+      # [<tt>identifier</tt>]   Commit identifier
+      # [<tt>author</tt>]       Commit author's name and email
+      # [<tt>message</tt>]      Commit message
+      # [<tt>committed_at</tt>] Commit date (as a <tt>Time</tt> object)
+      def info(commit)
+        raise NotImplementedError
       end
 
-      def path_from_uri
+      # Return the identifier for the last commit in this branch of the
+      # repository.
+      def head
         raise NotImplementedError
       end
+
+      private
+        def run(cmd, dir=nil)
+          cmd = "(#{dir ? "cd #{dir} && " : ""}#{cmd} &>/dev/null)"
+          Bob.logger.debug(cmd)
+          system(cmd) || raise(Error, "Couldn't run SCM command `#{cmd}`")
+        end
+
+        def path
+          @path ||= "#{uri}-#{branch}".
+            gsub(/[^\w_ \-]+/i, '-').# Remove unwanted chars.
+            gsub(/[ \-]+/i, '-').    # No more than one of the separator in a row.
+            gsub(/^\-|\-$/i, '')     # Remove leading/trailing separator.
+        end
+
+        def resolve(commit)
+          commit == :head ? head : commit
+        end
     end
   end
 end

data/lib/bob/scm/git.rb

@@ -1,57 +1,31 @@
 module Bob
   module SCM
     class Git < Abstract
-      def info(commit_id)
-        format  = %Q(---%n:author: %an <%ae>%n:message: >-%n  %s%n:committed_at: %ci%n)
-        YAML.load(`cd #{working_dir} && git show -s --pretty=format:"#{format}" #{commit_id}`).tap do |info|
-          info[:committed_at] = Time.parse(info[:committed_at])
-        end
-      end
+      def info(commit)
+        format = "---%nidentifier: %H%nauthor: %an " +
+          "<%ae>%nmessage: >-%n  %s%ncommitted_at: %ci%n"
 
-      protected
+        dump = YAML.load(`cd #{dir_for(commit)} && git show -s \
+          --pretty=format:"#{format}" #{commit}`)
 
-      def path_from_uri
-        path = uri.path.
-          gsub(/\~[a-z0-9]*\//i, ""). # remove ~foobar/
-          gsub(/\s+|\.|\//, "-").     # periods, spaces, slashes -> hyphens
-          gsub(/^-+|-+$/, "")         # remove trailing hyphens
-        path += "-#{branch}"
+        dump.update("committed_at" => Time.parse(dump["committed_at"]))
       end
 
-      private
-
-      def update_code
-        cloned? ? fetch : clone
+      def head
+        `git ls-remote --heads #{uri} #{branch} | cut -f1`.chomp
       end
 
-      def cloned?
-        File.directory?("#{working_dir}/.git")
-      end
-
-      def clone
-        git "clone #{uri} #{working_dir}"
-      rescue CantRunCommand
-        FileUtils.rm_r working_dir
-        retry
-      end
-
-      def fetch
-        git "fetch origin"
-      end
-
-      def checkout(commit_id)
-        # First checkout the branch just in case the commit_id turns out to be HEAD or other non-sha identifier
-        git "checkout origin/#{branch}"
-        git "reset --hard #{commit_id}"
-      end
-
-      def reset(commit_id)
-        git "reset --hard #{commit_id}"
-      end
+      private
+        def checkout(commit)
+          run "git clone #{uri} #{dir_for(commit)}" unless cloned?(commit)
+          run "git fetch origin", dir_for(commit)
+          run "git checkout origin/#{branch}", dir_for(commit)
+          run "git reset --hard #{commit}", dir_for(commit)
+        end
 
-      def git(command)
-        run "git #{command}"
-      end
+        def cloned?(commit)
+          dir_for(commit).join(".git").directory?
+        end
     end
   end
 end

data/lib/bob/scm/svn.rb

@@ -0,0 +1,30 @@
+module Bob
+  module SCM
+    class Svn < Abstract
+      def info(rev)
+        dump = `svn log --non-interactive --revision #{rev} #{uri}`.split("\n")
+        meta = dump[1].split(" | ")
+
+        { "identifier"   => rev,
+          "message"      => dump[3],
+          "author"       => meta[1],
+          "committed_at" => Time.parse(meta[2]) }
+      end
+
+      def head
+        `svn info #{uri}`.split("\n").detect { |l| l =~ /^Revision: (\d+)/ }
+        $1.to_s
+      end
+
+      private
+        def checkout(rev)
+          run "svn co -q #{uri} #{dir_for(rev)}" unless checked_out?(rev)
+          run "svn up -q -r#{rev}", dir_for(rev)
+        end
+
+        def checked_out?(rev)
+          dir_for(rev).join(".svn").directory?
+        end
+    end
+  end
+end

data/lib/bob/test.rb

@@ -0,0 +1,3 @@
+require "bob"
+require "bob/test/repo"
+require "bob/test/builder_stub"

data/lib/bob/test/builder_stub.rb

@@ -0,0 +1,34 @@
+module Bob
+  module Test
+    class BuilderStub < Bob::Builder
+      def self.for(repo, commit)
+        new(
+          "scm"    => repo.scm,
+          "uri"    => repo.uri,
+          "branch" => repo.branch,
+          "commit" => commit,
+          "command" => repo.command
+        )
+      end
+
+      attr_reader :status, :output, :commit_info
+
+      def initialize(buildable)
+        super
+
+        @status = nil
+        @output = ""
+        @commit_info = {}
+      end
+
+      def started(commit_info)
+        @commit_info = commit_info
+      end
+
+      def completed(status, output)
+        @status = status ? :successful : :failed
+        @output = output
+      end
+    end
+  end
+end

data/lib/bob/test/repo.rb

@@ -0,0 +1,163 @@
+module Bob::Test
+  class AbstractRepo
+    def initialize(name = "test_repo")
+      @path = Bob.directory.join(name)
+    end
+
+    def create
+      add_commit("First commit") {
+        `echo 'just a test repo' >> README`
+        add "README"
+      }
+    end
+
+    def add_commit(message)
+      Dir.chdir(@path) {
+        yield
+        commit(message)
+      }
+    end
+
+    def add_successful_commit
+      add_commit("This commit will work") {
+        `echo '#{script(0)}' > test`
+        `chmod +x test`
+        add "test"
+      }
+    end
+
+    def add_failing_commit
+      add_commit("This commit will fail") {
+        system "echo '#{script(1)}' > test"
+        system "chmod +x test"
+        add    "test"
+      }
+    end
+
+    def head
+      commits.last["identifier"]
+    end
+
+    def short_head
+      head[0..6]
+    end
+
+    def command
+      "./test"
+    end
+
+    def script(status)
+      <<SH
+#!/bin/sh
+echo "Running tests..."
+exit #{status}
+SH
+    end
+  end
+
+  class GitRepo < AbstractRepo
+    def scm
+      "git"
+    end
+
+    def branch
+      "master"
+    end
+
+    def uri
+      @path
+    end
+
+    def add(file)
+      `git add #{file}`
+    end
+
+    def commit(message)
+      `git commit -m "#{message}"`
+    end
+
+    def head
+      Dir.chdir(@path) { `git log --pretty=format:%H | head -1`.chomp }
+    end
+
+    def create
+      FileUtils.mkdir(@path)
+
+      Dir.chdir(@path) {
+        `git init`
+        `git config user.name 'John Doe'`
+        `git config user.email 'johndoe@example.org'`
+      }
+
+      super
+    end
+
+    def commits
+      Dir.chdir(@path) {
+        `git log --pretty=oneline`.collect { |l| l.split(" ").first }.
+        inject([]) { |acc, sha1|
+          fmt  = "---%nmessage: >-%n  %s%ntimestamp: %ci%n" +
+            "identifier: %H%nauthor: %n name: %an%n email: %ae%n"
+          acc << YAML.load(`git show -s --pretty=format:"#{fmt}" #{sha1}`)
+        }.reverse
+      }
+    end
+  end
+
+  class SvnRepo < AbstractRepo
+    def initialize(name = "test_repo")
+      super
+
+      server = @path.join("..", "svn-server")
+      server.mkdir
+      @remote = server.join(@path.basename)
+    end
+
+    def uri
+      "file://#{@remote}"
+    end
+
+    def branch
+      ""
+    end
+
+    def scm
+      "svn"
+    end
+
+    def commit(msg)
+      `svn commit -m "#{msg}"`
+      `svn up`
+    end
+
+    def add(file)
+      `svn add #{file}`
+    end
+
+    def create
+      `svnadmin create #{@remote}`
+
+      @remote.join("conf", "svnserve.conf").open("w") { |f|
+        f.puts "[general]"
+        f.puts "anon-access = write"
+        f.puts "auth-access = write"
+      }
+
+      `svn checkout file://#{@remote} #{@path}`
+
+      super
+    end
+
+    # TODO get rid of the Hpricot dependency
+    def commits
+      Dir.chdir(@path) do
+        doc = Hpricot::XML(`svn log --xml`)
+        (doc/:log/:logentry).inject([]) { |acc, c|
+          acc << { "identifier" => c["revision"],
+            "message"      => c.at("msg").inner_html,
+            "committed_at" => Time.parse(c.at("date").inner_html) }
+        }.reverse
+      end
+    end
+  end
+end

data/test/bob_test.rb

@@ -1,9 +1,10 @@
-require File.dirname(__FILE__) + "/helper"
+require "helper"
 
 class BobTest < Test::Unit::TestCase
   test "directory" do
     Bob.directory = "/foo/bar"
-    assert_equal "/foo/bar", Bob.directory
+    assert_equal "/foo/bar", Bob.directory.to_s
+    assert_instance_of Pathname, Bob.directory
   end
 
   test "logger" do

data/test/deps.rip

@@ -0,0 +1,3 @@
+contest 0.1.2
+hpricot 0.8.1
+redgreen 1.2.2

data/test/engine/threaded_test.rb

@@ -0,0 +1,52 @@
+require "helper"
+
+class ThreadedBobTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = GitRepo.new(:test_repo)
+    @repo.create
+  end
+
+  test "with a successful threaded build" do
+    old_engine = Bob.engine
+
+    repo.add_successful_commit
+    commit_id = repo.commits.last["identifier"]
+    buildable = BuildableStub.for(@repo, commit_id)
+
+    begin
+      Thread.abort_on_exception = true
+      Bob.engine = Bob::Engine::Threaded.new(5)
+      buildable.build
+      Bob.engine.wait!
+
+      assert_equal :successful,          buildable.status
+      assert_equal "Running tests...\n", buildable.output
+
+      commit = buildable.commit_info
+      assert_equal "This commit will work", commit["message"]
+      assert_equal Time.now.min,            commit["committed_at"].min
+    ensure
+      Bob.engine = old_engine
+    end
+  end
+
+  class FakeLogger
+    attr_reader :msg
+
+    def error(msg)
+      @msg = msg
+    end
+  end
+
+  test "when something goes wrong" do
+    logger = FakeLogger.new
+
+    engine = Bob::Engine::Threaded.new(2, logger)
+    engine.call(proc { fail "foo" })
+    engine.wait!
+
+    assert_equal "Exception occured during build: foo", logger.msg
+  end
+end