jeroenvandijk-bob 0.3.1

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2008-2009 Nicolas Sanguinetti, entp.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,30 @@
+= Bob the Builder
+
+Given a Buildable object with a determined API (described in it's documentation), 
+Bob will, when called like:
+
+    Bob.build(buildable, commit_id) # or Bob.build(buildable, [commit_id, commit_id, ...])
+
+or from your buildable (if you are using the Bob::Buildable mixin provided) as:
+
+    buildable.build(commit_id) # or buildable.build([commit_id, commit_id, ...])
+
+1. Checkout the buildable on the specified commit
+2. Call <tt>Buildable#start_building</tt>
+3. Run the script provided in <tt>Buildable#build_script</tt> in the buildable.
+4. When the build process finishes, it will call <tt>Buildable#finish_building</tt> with
+   the commit_id, the build status (true if the script returns a status code
+   of 0, false otherwise), and a string with the build output (both STDOUT and STDERR).
+
+If you pass an array of commits, the steps 1-4 will be repeated for each commit provided,
+in order.
+
+== Do I need this?
+
+Probably not. Check out integrity[http://integrityapp.com] for a full fledged
+automated CI server, which is what most people need.
+
+== Credits
+
+Authors:: Nicolas Sanguinetti (foca[http://github.com/foca]) and Simon Rozet (sr[http://github.com/sr])
+License:: MIT (Check LICENSE for details)

data/Rakefile

@@ -0,0 +1,70 @@
+require "rake/testtask"
+
+rdoc_sources = %w(hanna/rdoctask rdoc/task rake/rdoctask)
+begin
+  require rdoc_sources.shift
+rescue LoadError
+  retry
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "bob"
+    s.rubyforge_project = "integrity"
+    s.summary = "Bob builds!"
+    s.email = "info@integrityapp.com"
+    s.homepage = "http://integrityapp.com"
+    s.description = "Bob the Builder will build your code. Simple."
+    s.authors = ["Nicolás Sanguinetti", "Simon Rozet"]
+    s.files = FileList["[A-Z]*", "{lib}/**/*"]
+
+    s.add_dependency "addressable"
+    s.add_dependency "ninja"
+    s.has_rdoc          = true
+    if s.respond_to?(:add_development_dependency)
+      s.add_development_dependency "sr-mg"
+      s.add_development_dependency "contest"
+      s.add_development_dependency "redgreen"
+      s.add_development_dependency "ruby-debug"
+    end
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+begin
+  require "metric_fu" if RUBY_VERSION < "1.9"
+rescue LoadError
+end
+
+begin
+  require "mg"
+  MG.new("bob.gemspec")
+rescue LoadError
+end
+
+desc "Default: run all tests"
+task :default => :test
+
+SCMs = %w[git svn]
+
+desc "Run unit tests"
+task :test => SCMs.map { |scm| "test:#{scm}" } do
+  ruby "test/bob_test.rb"
+  ruby "test/test_test.rb"
+end
+
+SCMs.each { |scm|
+  desc "Run unit tests with #{scm}"
+  task "test:#{scm}" do
+    ruby "test/scm/#{scm}_test.rb"
+  end
+}
+
+(defined?(RDoc::Task) ? RDoc::Task : Rake::RDocTask).new do |rd|
+  rd.main = "README.rdoc"
+  rd.title = "Documentation for Bob the Builder"
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
+  rd.rdoc_dir = "doc"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.1

data/lib/bob.rb

@@ -0,0 +1,35 @@
+require "fileutils"
+require "pathname"
+require "yaml"
+require "logger"
+require "time"
+require "ninja"
+require "addressable/uri"
+
+require "bob/buildable"
+require "bob/builder"
+require "bob/scm"
+
+module Bob
+  # Builds the specified <tt>buildable</tt>. This object must understand
+  # the API described in the README.
+  def self.build(buildable)
+    Builder.new(buildable).build
+  end
+
+  # Directory where the code for the different buildables will be checked out.
+  # Make sure the user running Bob is allowed to write to this directory.
+  def self.directory
+    Pathname(@directory || "/tmp")
+  end
+
+  # What to log with (must implement ruby's Logger interface). Logs to STDOUT
+  # by default.
+  def self.logger
+    @logger || Logger.new(STDOUT)
+  end
+
+  class << self
+    attr_writer :directory, :logger
+  end
+end

data/lib/bob/buildable.rb

@@ -0,0 +1,74 @@
+module Bob
+  # Mixin to add to your classes.
+  module Buildable
+    # Build itself.
+    def build
+      Bob.build(self)
+    end
+
+    # What kind of repository this buildable represents. Must
+    # return a String ("git", "svn", etc.)
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def scm
+      raise NotImplementedError
+    end
+
+    # Full URI to the repository to clone/checkout.
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def uri
+      raise NotImplementedError
+    end
+
+    # Branch of the code you want to watch in order to build.
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def branch
+      raise NotImplementedError
+    end
+
+    # Indentifier of the commit to build.
+    #
+    # The special identifier <tt>:head</tt> will be resolved to the head
+    # commit of the current branch (for example, "HEAD" under git or the
+    # latest revision under svn)
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def commit
+      raise NotImplementedError
+    end
+
+    # Script that will be run in the buildable's checked out code,
+    # if it returns a status code of 0 it will be considered a
+    # successfull build. Else it will be considered a failed build.
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def build_script
+      raise NotImplementedError
+    end
+
+    # Optional callback sent when the build starts. It can be used to calculate
+    # the build duration for example.
+    def start_building
+    end
+
+    # Callback sent after a build finishes. The first argument is a hash with
+    # information about the commit.
+    #
+    # <tt>identifier</tt>:: A string with the commit identifier of the
+    # commit that was built
+    # <tt>author</tt>:: A string with the name/email of the committer
+    # <tt>message</tt>:: The commit message
+    # <tt>committed_at</tt>:: A Time object with the timestamp of the commit
+    #
+    # The second argument is a boolean indicating whether the build was
+    # successful. Finally, the last one is a string with the full output
+    # returned by the build process (STDOUT and STDERR interleaved)
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def finish_building(commit_info, build_status, build_output)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/bob/builder.rb

@@ -0,0 +1,53 @@
+module Bob
+  # A Builder will take care of building a buildable (wow, you didn't see
+  # that coming, right?).
+  class Builder
+    attr_reader :buildable
+
+    include Ninja
+
+    # Instantiate the Builder, passing an object that understands
+    # the <tt>Buildable</tt> interface.
+    def initialize(buildable)
+      @buildable = buildable
+    end
+
+    # This is where the magic happens:
+    #
+    # 1. Notify the buildable that the build is starting.
+    # 2. Check out the repo to the appropriate commit.
+    # 3. Run the build script on it.
+    # 4. Reports the build back to the buildable.
+    def build
+      Bob.logger.info "Building #{buildable.commit} of the #{buildable.scm} repo at #{buildable.uri}"
+
+      in_background do
+        buildable.start_building if buildable.respond_to?(:start_building)
+
+        scm.with_commit(buildable.commit) { |commit_info|
+          buildable.finish_building(commit_info, *run_build_script)
+        }
+      end
+    end
+
+    private
+
+    def run_build_script
+      build_output = nil
+
+      Bob.logger.debug("Running the build script for #{buildable.uri}")
+      IO.popen(build_script, "r") { |output| build_output = output.read }
+      Bob.logger.debug("Ran build script `#{build_script}` and got:\n#{build_output}")
+
+      [$?.success?, build_output]
+    end
+
+    def build_script
+      "(cd #{scm.dir_for(buildable.commit)} && #{buildable.build_script} 2>&1)"
+    end
+
+    def scm
+      @scm ||= SCM.new(buildable.scm, buildable.uri, buildable.branch)
+    end
+  end
+end

data/lib/bob/scm.rb

@@ -0,0 +1,25 @@
+require "bob/scm/abstract"
+
+module Bob
+  module SCM
+    autoload :Git, "bob/scm/git"
+    autoload :Svn, "bob/scm/svn"
+
+    class Error < StandardError; end
+
+    # Factory to return appropriate SCM instances (according to repository kind)
+    def self.new(scm, uri, branch)
+      class_for(scm).new(uri, branch)
+    end
+
+    # A copy of Inflector.camelize, from ActiveSupport. It will convert
+    # string to UpperCamelCase.
+    def self.class_for(string)
+      class_name = string.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

@@ -0,0 +1,65 @@
+module Bob
+  module SCM
+    class Abstract
+      attr_reader :uri, :branch
+
+      def initialize(uri, branch)
+        @uri    = Addressable::URI.parse(uri)
+        @branch = branch
+      end
+
+      # Checkout the code at the specified <tt>commit</tt> and call the
+      # passed block.
+      def with_commit(commit)
+        commit = resolve(commit)
+        checkout(commit)
+        yield info(commit)
+      end
+
+      # Directory where the code will be checked out for the given
+      # <tt>commit</tt>.
+      def dir_for(commit)
+        commit = resolve(commit)
+        Bob.directory.join(path, "-", commit)
+      end
+
+      protected
+
+      # 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
+
+      # Return the identifier for the last commit in this branch of the
+      # repository.
+      def head
+        raise NotImplementedError
+      end
+
+      def run(command, directory=nil)
+        command = "(#{directory ? "cd #{directory} && " : ""}#{command} &>/dev/null)"
+        Bob.logger.debug(command)
+        system(command) || raise(Error, "Couldn't run SCM command `#{command}`")
+      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
+
+      private
+
+      def resolve(commit)
+        commit == :head ? head : commit
+      end
+    end
+  end
+end

data/lib/bob/scm/git.rb

@@ -0,0 +1,34 @@
+module Bob
+  module SCM
+    class Git < Abstract
+      protected
+
+      def info(commit)
+        format = "---%nidentifier: %H%nauthor: %an \
+          <%ae>%nmessage: >-%n  %s%ncommitted_at: %ci%n"
+
+        dump = YAML.load(`cd #{dir_for(commit)} && git show -s \
+          --pretty=format:"#{format}" #{commit}`)
+
+        dump.update("committed_at" => Time.parse(dump["committed_at"]))
+      end
+
+      def head
+        `git ls-remote --heads #{uri} #{branch} | cut -f1`.chomp
+      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 cloned?(commit)
+        dir_for(commit).join(".git").directory?
+      end
+    end
+  end
+end

data/lib/bob/scm/svn.rb

@@ -0,0 +1,37 @@
+module Bob
+  module SCM
+    class Svn < Abstract
+      protected
+
+      def info(revision)
+        dump = `svn log --non-interactive --revision #{revision} #{uri}`.split("\n")
+        meta = dump[1].split(" | ")
+
+        { "identifier" => revision,
+          "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(revision)
+        unless checked_out?(revision)
+          run "svn co -q #{uri} #{dir_for(revision)}"
+        end
+
+        run "svn up -q -r#{revision}", dir_for(revision)
+      end
+
+      def checked_out?(commit)
+        dir_for(commit).join(".svn").directory?
+      end
+    end
+  end
+end

data/lib/bob/test.rb

@@ -0,0 +1,4 @@
+require "bob"
+require "bob/test/buildable_stub"
+require "bob/test/scm/git"
+require "bob/test/scm/svn"

data/lib/bob/test/buildable_stub.rb

@@ -0,0 +1,43 @@
+module Bob
+  module Test
+    class BuildableStub
+      include Bob::Buildable
+
+      def self.for(repo, commit)
+        scm = (Bob::Test::GitRepo === repo) ? "git" : "svn"
+        uri =
+          if scm == "git"
+            repo.path
+          else
+            "file://#{SvnRepo.server_root}/#{repo.name}"
+          end
+        # TODO: move onto repo object?
+        branch = (scm == "git") ? "master" : ""
+        build_script = "./test"
+
+        new(scm, uri, branch, commit, build_script)
+      end
+
+      attr_reader :scm, :uri, :branch, :commit, :build_script,
+        :repo, :status, :output, :commit_info
+
+      def initialize(scm, uri, branch, commit, build_script)
+        @scm = scm.to_s
+        @uri = uri.to_s
+        @branch = branch
+        @commit = commit
+        @build_script = build_script
+
+        @status = nil
+        @output = ""
+        @commit_info = {}
+      end
+
+      def finish_building(commit_info, status, output)
+        @commit_info = commit_info
+        @status = status ? :successful : :failed
+        @output = output
+      end
+    end
+  end
+end

data/lib/bob/test/scm/abstract.rb

@@ -0,0 +1,62 @@
+module Bob::Test
+  class AbstractSCMRepo
+    attr_reader :path, :name
+
+    def initialize(name, base_dir=Bob.directory)
+      @name   = name
+      @path   = File.join(base_dir, @name.to_s)
+    end
+
+    def add_commit(message, &action)
+      Dir.chdir(path) do
+        yield action
+        commit(message)
+      end
+    end
+
+    def add_failing_commit
+      add_commit "This commit will fail" do
+        system "echo '#{build_script(false)}' > test"
+        system "chmod +x test"
+        add    "test"
+      end
+    end
+
+    def add_successful_commit
+      add_commit "This commit will work" do
+        system "echo '#{build_script(true)}' > test"
+        system "chmod +x test"
+        add    "test"
+      end
+    end
+
+    def commits
+      raise NotImplementedError
+    end
+
+    def head
+      commits.last["identifier"]
+    end
+
+    protected
+      def add(file)
+        raise NotImplementedError
+      end
+
+      def commit(message)
+        raise NotImplementedError
+      end
+
+      def run(command)
+        system "#{command} &>/dev/null"
+      end
+
+      def build_script(successful=true)
+        <<-script
+#!/bin/sh
+echo "Running tests..."
+exit #{successful ? 0 : 1}
+script
+      end
+  end
+end

data/lib/bob/test/scm/git.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/abstract"
+
+module Bob::Test
+  class GitRepo < AbstractSCMRepo
+    def create
+      FileUtils.mkdir(path)
+
+      Dir.chdir(path) do
+        run "git init"
+        run "git config user.name 'John Doe'"
+        run "git config user.email 'johndoe@example.org'"
+        run "echo 'just a test repo' >> README"
+        add "README"
+        commit "First commit"
+      end
+    end
+
+    def commits
+      Dir.chdir(path) do
+        commits = `git log --pretty=oneline`.collect { |l| l.split(" ").first }
+        commits.inject([]) do |commits, sha1|
+          format  = "---%nmessage: >-%n  %s%ntimestamp: %ci%n" +
+            "identifier: %H%nauthor: %n name: %an%n email: %ae%n"
+          commits << YAML.load(`git show -s --pretty=format:"#{format}" #{sha1}`)
+        end.reverse
+      end
+    end
+
+    def head
+      Dir.chdir(path) do
+        `git log --pretty=format:%H | head -1`.chomp
+      end
+    end
+
+    def short_head
+      head[0..6]
+    end
+
+    protected
+      def add(file)
+        run "git add #{file}"
+      end
+
+      def commit(message)
+        run %Q{git commit -m "#{message}"}
+      end
+  end
+end

data/lib/bob/test/scm/svn.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + "/abstract"
+require "hpricot"
+
+module Bob::Test
+  class SvnRepo < AbstractSCMRepo
+    def self.server_root
+      @root ||= Bob.directory.join("svn")
+    end
+
+    attr_reader :remote
+
+    def initialize(name, base_dir=Bob.directory)
+      super
+
+      @path   = base_dir.join("svn-#{name}")
+      @remote = SvnRepo.server_root.join(name.to_s)
+    end
+
+    def create
+      create_remote
+
+      run "svn checkout file://#{remote} #{path}"
+
+      add_commit("First commit") do
+        run "echo 'just a test repo' >> README"
+        add "README"
+      end
+    end
+
+    def commits
+      Dir.chdir(path) do
+        doc = Hpricot::XML(`svn log --xml`)
+
+        (doc/:log/:logentry).inject([]) { |commits, commit|
+          commits << { "identifier" => commit["revision"],
+            "message"      => commit.at("msg").inner_html,
+            "committed_at" => Time.parse(commit.at("date").inner_html) }
+        }.reverse
+      end
+    end
+
+    alias_method :short_head, :head
+
+    protected
+      def add(file)
+        run "svn add #{file}"
+      end
+
+      def commit(message)
+        run %Q{svn commit -m "#{message}"}
+        run "svn up"
+      end
+
+    private
+      def create_remote
+        SvnRepo.server_root.mkdir
+
+        run "svnadmin create #{remote}"
+
+        File.open(File.join(remote, "conf", "svnserve.conf"), "w") { |f|
+          f.puts "[general]"
+          f.puts "anon-access = write"
+          f.puts "auth-access = write"
+        }
+      end
+  end
+end

data/test/bob_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BobTest < Test::Unit::TestCase
+  test "directory" do
+    Bob.directory = "/foo/bar"
+    assert_equal "/foo/bar", Bob.directory.to_s
+    assert_instance_of Pathname, Bob.directory
+  end
+
+  test "logger" do
+    logger = Logger.new("/tmp/bob.log")
+    Bob.logger = logger
+
+    assert_same logger, Bob.logger
+  end
+end

data/test/engine/threaded_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + "/../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

data/test/helper.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+require "contest"
+require "hpricot"
+
+begin
+  require "redgreen"
+  require "ruby-debug"
+rescue LoadError
+end
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"),
+  File.expand_path(File.dirname(__FILE__) + "/../test/helper"))
+
+require "bob"
+require "bob/test"
+
+class Test::Unit::TestCase
+  include Bob
+  include Bob::Test
+
+  attr_reader :repo
+
+  def setup
+    Bob.logger = Logger.new("/dev/null")
+    Bob.directory = Pathname(__FILE__).dirname.join("..", "tmp").expand_path
+
+    Bob.directory.rmtree if Bob.directory.directory?
+    Bob.directory.mkdir
+  end
+end

data/test/scm/git_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobGitTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = GitRepo.new(:test_repo)
+    @repo.create
+  end
+
+  def path(uri, branch="master")
+    SCM::Git.new(uri, branch).__send__(:path)
+  end
+
+  test "converts repo uri into a path" do
+    assert_equal "git-github-com-integrity-bob-master",
+      path("git://github.com/integrity/bob")
+    assert_equal "git-example-org-foo-repo-master",
+      path("git@example.org:~foo/repo")
+    assert_equal "tmp-repo-git-master", path("/tmp/repo.git")
+    assert_equal "tmp-repo-git-foo",    path("/tmp/repo.git", "foo")
+  end
+
+  test "with a successful build" do
+    repo.add_successful_commit
+
+    commit_id = repo.commits.last["identifier"]
+
+    buildable = BuildableStub.for(@repo, commit_id)
+    buildable.build
+
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will work", buildable.commit_info["message"]
+    assert_equal commit_id,               buildable.commit_info["identifier"]
+    assert buildable.commit_info["committed_at"].is_a?(Time)
+  end
+
+  test "with a failed build" do
+    repo.add_failing_commit
+
+    commit_id = repo.commits.last["identifier"]
+    buildable = BuildableStub.for(@repo, commit_id)
+
+    buildable.build
+
+    assert_equal :failed,              buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will fail", buildable.commit_info["message"]
+    assert_equal commit_id,               buildable.commit_info["identifier"]
+    assert buildable.commit_info["committed_at"].is_a?(Time)
+  end
+
+  test "can build the head of a repository" do
+    repo.add_failing_commit
+    repo.add_successful_commit
+
+    buildable = BuildableStub.for(@repo, :head)
+
+    buildable.build
+
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal repo.head,            buildable.commit_info["identifier"]
+  end
+end

data/test/scm/svn_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobSvnTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = SvnRepo.new(:test_repo)
+    @repo.create
+  end
+
+  def path(uri)
+    SCM::Svn.new(uri, "").__send__(:path)
+  end
+
+  test "converts svn repo uri into a path" do
+    assert_equal "http-rubygems-rubyforge-org-svn",
+      path("http://rubygems.rubyforge.org/svn/")
+
+    assert_equal "svn-rubyforge-org-var-svn-rubygems",
+      path("svn://rubyforge.org/var/svn/rubygems")
+
+    assert_equal "svn-ssh-developername-rubyforge-org-var-svn-rubygems",
+      path("svn+ssh://developername@rubyforge.org/var/svn/rubygems")
+
+    assert_equal "home-user-code-repo",
+      path("/home/user/code/repo")
+  end
+
+  test "with a successful build" do
+    repo.add_successful_commit
+
+    buildable = BuildableStub.for(@repo, "2")
+    buildable.build
+
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will work", buildable.commit_info["message"]
+    assert_equal "2",                     buildable.commit_info["identifier"]
+    assert buildable.commit_info["committed_at"].is_a?(Time)
+  end
+
+  test "with a failed build" do
+    repo.add_failing_commit
+
+    buildable = BuildableStub.for(@repo, "2")
+    buildable.build
+
+    assert_equal :failed,              buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will fail", buildable.commit_info["message"]
+    assert_equal "2",                     buildable.commit_info["identifier"]
+    assert buildable.commit_info["committed_at"].is_a?(Time)
+  end
+
+  test "can build the head of a repository" do
+    repo.add_failing_commit
+    repo.add_successful_commit
+
+    buildable = BuildableStub.for(@repo, :head)
+    buildable.build
+
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal repo.head,            buildable.commit_info["identifier"]
+  end
+end

data/test/test_test.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BobTestTest < Test::Unit::TestCase
+  def assert_scm_repo(repo)
+    repo.create
+
+    assert_equal 1, repo.commits.size
+    assert_equal "First commit", repo.commits.first["message"]
+
+    repo.add_failing_commit
+    assert_equal 2, repo.commits.size
+    assert_equal "This commit will fail", repo.commits.last["message"]
+    assert_equal repo.commits.last["identifier"], repo.head
+    assert repo.short_head
+
+    repo.add_successful_commit
+    assert_equal 3, repo.commits.size
+    assert_equal "This commit will work", repo.commits.last["message"]
+    assert_equal repo.commits.last["identifier"], repo.head
+  end
+
+  def test_buildable_stub
+    b = BuildableStub.new(:git, "git://github.com/ry/node", "master", "HEAD", "make")
+
+    assert_equal "git",                      b.scm
+    assert_equal "git://github.com/ry/node", b.uri
+    assert_equal "master",                   b.branch
+    assert_equal "HEAD",                     b.commit
+    assert_equal "make",                     b.build_script
+  end
+
+  def test_scm_repo
+    assert_scm_repo(GitRepo.new(:my_test_project))
+    assert_scm_repo(SvnRepo.new(:my_test_project))
+  end
+
+  def test_buildable_git_repo
+    repo = GitRepo.new(:test_repo)
+    repo.create
+
+    b = BuildableStub.for(repo, repo.head)
+
+    assert_equal "git",                    b.scm
+    assert_equal "#{Bob.directory}/test_repo", b.uri
+    assert_equal "master",                 b.branch
+    assert_equal repo.head,                b.commit
+    assert_equal "./test",                 b.build_script
+  end
+
+  def test_buildable_svn_repo
+    repo = SvnRepo.new(:test_repo)
+    repo.create
+
+    b = BuildableStub.for(repo, repo.head)
+
+    assert_equal "svn",     b.scm
+    assert_equal "",        b.branch
+    assert_equal repo.head, b.commit
+    assert_equal "./test",  b.build_script
+    assert_equal "file://#{Bob.directory}/svn/test_repo", b.uri
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: jeroenvandijk-bob
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- "Nicol\xC3\xA1s Sanguinetti"
+- Simon Rozet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ninja
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sr-mg
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: contest
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Bob the Builder will build your code. Simple.
+email: info@integrityapp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/bob.rb
+- lib/bob/buildable.rb
+- lib/bob/builder.rb
+- lib/bob/scm.rb
+- lib/bob/scm/abstract.rb
+- lib/bob/scm/git.rb
+- lib/bob/scm/svn.rb
+- lib/bob/test.rb
+- lib/bob/test/buildable_stub.rb
+- lib/bob/test/scm/abstract.rb
+- lib/bob/test/scm/git.rb
+- lib/bob/test/scm/svn.rb
+has_rdoc: false
+homepage: http://integrityapp.com
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: integrity
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Bob builds!
+test_files: 
+- test/bob_test.rb
+- test/engine/threaded_test.rb
+- test/helper.rb
+- test/scm/git_test.rb
+- test/scm/svn_test.rb
+- test/test_test.rb