integrity-bob 0.2.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+dist/*
+tmp/*
+test/tmp/*
+doc/*

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,44 @@
+require "rake/testtask"
+
+rdoc_sources = %w(hanna/rdoctask rdoc/task rake/rdoctask)
+begin
+  require rdoc_sources.shift
+rescue LoadError
+  retry
+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/engine/threaded_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/bob.gemspec

@@ -0,0 +1,51 @@
+Gem::Specification.new do |s|
+  s.name    = "bob"
+  s.version = "0.2.0"
+  s.date    = "2009-07-02"
+
+  s.description = "Bob the Builder will build your code. Simple."
+  s.summary     = "Bob builds!"
+  s.homepage    = "http://integrityapp.com"
+
+  s.authors = ["Nicolás Sanguinetti", "Simon Rozet"]
+  s.email   = "info@integrityapp.com"
+
+  s.require_paths     = ["lib"]
+  s.rubyforge_project = "integrity"
+  s.has_rdoc          = true
+  s.rubygems_version  = "1.3.1"
+
+  s.add_dependency "addressable"
+
+  if s.respond_to?(:add_development_dependency)
+    s.add_development_dependency "sr-mg"
+    s.add_development_dependency "sr-bob-test"
+    s.add_development_dependency "contest"
+    s.add_development_dependency "redgreen"
+    s.add_development_dependency "ruby-debug"
+  end
+
+  s.files = %w[
+.gitignore
+LICENSE
+README.rdoc
+Rakefile
+bob.gemspec
+lib/bob.rb
+lib/bob/buildable.rb
+lib/bob/builder.rb
+lib/bob/engine.rb
+lib/bob/engine/foreground.rb
+lib/bob/engine/threaded.rb
+lib/bob/scm.rb
+lib/bob/scm/abstract.rb
+lib/bob/scm/git.rb
+lib/bob/scm/svn.rb
+lib/core_ext/object.rb
+test/bob_test.rb
+test/engine/threaded_test.rb
+test/helper.rb
+test/scm/git_test.rb
+test/scm/svn_test.rb
+]
+end

data/lib/bob/buildable.rb

@@ -0,0 +1,70 @@
+module Bob
+  # Mixin to add to your classes.
+  module Buildable
+    # Builds the list of commits you pass. You must provide an
+    # enumerable with commit identifiers appropriate to the
+    # repository the code is in (SHAs if git, rev numbers if svn,
+    # etc), or a single string with a commit id.
+    def build(commits)
+      Bob.build(self, commits)
+    end
+
+    # What kind of repository this buildable represents. Must
+    # return a Symbol (: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
+
+    # 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
+
+    # Callback sent when a build starts. The first argument is a
+    # string with whatever identifier is appropriate for a repository
+    # of this kind. The second is a hash with information about the
+    # commit.
+    #
+    # <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
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def start_building(commit_id, commit_info)
+      raise NotImplementedError
+    end
+
+    # Callback sent after a build finishes. The first argument is a
+    # string with whatever identifier is appropriate for a respository
+    # of this kind. The second is a boolean which is true if the build
+    # was successful or false if it failed. And 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_id, build_status, build_output)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/bob/builder.rb

@@ -0,0 +1,64 @@
+module Bob
+  # A Builder will take care of building a buildable (wow, you didn't see that coming,
+  # right?).
+  class Builder
+    attr_reader :buildable
+
+    # Instantiate the Builder, passing an object that understands the <tt>Buildable</tt>
+    # interface, and a <tt>commit_id</tt>.
+    #
+    # You can pass <tt>:head</tt> as the commit id, in which case it will resolve to the
+    # head commit of the current branch (for example, "HEAD" under git, or the latest
+    # revision under svn)
+    def initialize(buildable, commit_id)
+      @buildable = buildable
+      @commit_id = commit_id
+    end
+
+    # This is where the magic happens:
+    #
+    # 1. Check out the repo to the appropriate commit.
+    # 2. Notify the buildable that the build is starting.
+    # 3. Run the build script on it in the background.
+    # 4. Reports the build back to the buildable.
+    def build
+      Bob.logger.info "Building #{commit_id} of the #{buildable.scm} repo at #{buildable.uri}"
+
+      in_background do
+        scm.with_commit(commit_id) {
+          buildable.start_building(commit_id, scm.info(commit_id))
+          build_status, build_output = run_build_script
+          buildable.finish_building(commit_id, build_status, build_output)
+        }
+      end
+    end
+
+    private
+
+    def commit_id
+      @commit_id == :head ? scm.head : @commit_id
+    end
+
+    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.working_dir} && #{buildable.build_script} 2>&1)"
+    end
+
+    def scm
+      @scm ||= SCM.new(buildable.scm, buildable.uri, buildable.branch)
+    end
+
+    def in_background(&block)
+      Bob.engine.call(block)
+    end
+  end
+end

data/lib/bob/engine/foreground.rb

@@ -0,0 +1,6 @@
+module Bob
+  module Engine
+    # Dummy engine that just runs in the foreground (useful for tests).
+    Foreground = lambda {|b| b.call }
+  end
+end

data/lib/bob/engine/threaded.rb

@@ -0,0 +1,138 @@
+require "thread"
+
+module Bob
+  module Engine
+    # A thread pool based build engine. This engine simply adds jobs to an
+    # in-memory queue, and processes them as soon as possible.
+    class Threaded
+      # The optional pool size controls how many threads will be created.
+      def initialize(pool_size = 2)
+        @pool = ThreadPool.new(pool_size)
+      end
+
+      # Adds a job to the queue.
+      def call(job)
+        @pool << job
+      end
+
+      # The number of jobs currently in the queue.
+      def njobs
+        @pool.njobs
+      end
+
+      # This method will not return until #njobs returns 0.
+      def wait!
+        Thread.pass until @pool.njobs == 0
+      end
+
+      # Manage a pool of threads, allowing for spin up / spin down of the
+      # contained threads.
+      # Simply processes work added to it's queue via #push.
+      # The default size for the pool is 2 threads.
+      class ThreadPool
+        # A thread safe single value for use as a counter.
+        class Incrementor
+          # The value passed in will be the initial value.
+          def initialize(v = 0)
+            @m = Mutex.new
+            @v = v
+          end
+
+          # Add the given value to self, default 1.
+          def inc(v = 1)
+            sync { @v += v }
+          end
+
+          # Subtract the given value to self, default 1.
+          def dec(v = 1)
+            sync { @v -= v }
+          end
+
+          # Simply shows the value inspect for convenience.
+          def inspect
+            @v.inspect
+          end
+
+          # Extract the value.
+          def to_i
+            @v
+          end
+
+          private
+
+          # Wrap the given block in a mutex.
+          def sync(&b)
+            @m.synchronize &b
+          end
+        end
+
+        # The number of threads in the pool.
+        attr_reader :size
+
+        # The job queue.
+        attr_reader :jobs
+
+        # Set the size of the thread pool. Asynchronously run down threads
+        # that are no longer required, and synchronously spawn new required
+        # threads.
+        def size=(other)
+          @size = other
+
+          if @workers.size > @size
+            (@workers.size - @size).times do
+              @workers.shift[:run] = false
+            end
+          else
+            (@size - @workers.size).times do
+              @workers << spawn
+            end
+          end
+        end
+
+        # Default pool size is 2 threads.
+        def initialize(size = nil)
+          size ||= 2
+          @jobs    = Queue.new
+          @njobs   = Incrementor.new
+          @workers = Array.new(size) { spawn }
+        end
+
+        # Adds a job to the queue, the job can be any number of objects
+        # responding to call, and/or a block.
+        def add(*jobs, &blk)
+          jobs = jobs + Array(blk)
+
+          jobs.each do |job|
+            @jobs << job
+            @njobs.inc
+          end
+        end
+
+        alias_method :push, :add
+        alias_method :<<,   :add
+
+        # A peak at the number of jobs in the queue. N.B. May differ, but
+        # should be more accurate than +jobs.size+.
+        def njobs
+          @njobs.to_i
+        end
+
+        private
+
+        # Create a new thread and return it. The thread will run until the
+        # thread-local value +:run+ is changed to false or nil.
+        def spawn
+          Thread.new do
+            c = Thread.current
+            c[:run] = true
+
+            while c[:run]
+              @jobs.pop.call
+              @njobs.dec
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bob/engine.rb

@@ -0,0 +1,9 @@
+module Bob
+  # Different engines to run code in background. An engine is any object
+  # that responds to #call and takes a Proc object, which should be executed
+  # "in the background". The different engines are:
+  module Engine
+    autoload :Foreground, "bob/engine/foreground"
+    autoload :Threaded,   "bob/engine/threaded"
+  end
+end

data/lib/bob/scm/abstract.rb

@@ -0,0 +1,59 @@
+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 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
+      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}".tap { |dir|
+          FileUtils.mkdir_p(dir)
+        }
+      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
+      end
+
+      # Return the identifier for the last commit in this branch of the
+      # repository.
+      def head
+        raise NotImplementedError
+      end
+
+      protected
+
+      def run(command, cd=true)
+        command = "(#{cd ? "cd #{working_dir} && " : ""}#{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
+    end
+  end
+end

data/lib/bob/scm/git.rb

@@ -0,0 +1,45 @@
+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 { |info|
+          info[:committed_at] = Time.parse(info[:committed_at])
+        }
+      end
+
+      def head
+        `git ls-remote --heads #{uri} #{branch} | cut -f1`.chomp
+      end
+
+      private
+
+      def update_code
+        cloned? ? fetch : clone
+      end
+
+      def cloned?
+        File.directory?("#{working_dir}/.git")
+      end
+
+      def clone
+        run "git clone #{uri} #{working_dir}", false
+      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 git(command)
+        run "git #{command}"
+      end
+    end
+  end
+end

data/lib/bob/scm/svn.rb

@@ -0,0 +1,45 @@
+require "bob/scm/abstract"
+
+module Bob
+  module SCM
+    class Svn < Abstract
+      def info(revision)
+        dump = `svn log --non-interactive --revision #{revision} #{uri}`.split("\n")
+        meta = dump[1].split(" | ")
+
+        { :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
+
+      def with_commit(commit_id)
+        update_code
+        checkout(commit_id)
+        yield
+      end
+
+    private
+
+      def update_code
+        initial_checkout unless checked_out?
+      end
+
+      def checkout(revision)
+        run("svn up -q -r#{revision}")
+      end
+
+      def initial_checkout(revision=nil)
+        run("svn co -q #{uri} #{working_dir}")
+      end
+
+      def checked_out?
+        File.directory?(working_dir + "/.svn")
+      end
+    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.rb

@@ -0,0 +1,57 @@
+require "fileutils"
+require "yaml"
+require "logger"
+require "time"
+require "addressable/uri"
+
+require "bob/buildable"
+require "bob/builder"
+require "bob/scm"
+require "bob/engine"
+require "core_ext/object"
+
+module Bob
+  # Builds the specified <tt>buildable</tt>. This object must understand
+  # the API described in the README.
+  #
+  # The second argument will take an array of commit_ids, which should be
+  # strings with the relevant identifier (a SHA1 hash for git repositories,
+  # a numerical revision for svn repositories, etc).
+  #
+  # You can pass :head as a commit identifier to build the latest commit
+  # in the repo. Examples:
+  #
+  #     Bob.build(buildable, :head) # just build the head
+  #     Bob.build(buildable, ["4", "3", "2"]) # build revision 4, 3, and 2
+  #                                           # (in that order)
+  #     Bob.build(buildable, [:head, "a30fb12"]) # build the HEAD and a30fb12
+  #                                              # commits in this repo.
+  def self.build(buildable, commit_ids)
+    Array(commit_ids).each do |commit_id|
+      Builder.new(buildable, commit_id).build
+    end
+  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
+    @directory || "/tmp"
+  end
+
+  # What will you use to build in background. Must respond to <tt>call</tt> and
+  # take a block which will be run "in background". The default is to run in
+  # foreground.
+  def self.engine
+    @engine || Engine::Foreground
+  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, :engine, :logger
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,7 @@
+class Object #:nodoc:
+  # Add Object#tap for backwards compatibility
+  def tap
+    yield self
+    self
+  end unless method_defined?(:tap)
+end

data/test/bob_test.rb

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

data/test/engine/threaded_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class ThreadedBobTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = GitRepo.new(:test_repo)
+    @repo.create
+
+    @buildable = BuildableStub.call(@repo)
+  end
+
+  test "with a successful threaded build" do
+    old_engine = Bob.engine
+
+    repo.add_successful_commit
+    commit_id = repo.commits.last[:identifier]
+
+    begin
+      Thread.abort_on_exception = true
+      Bob.engine = Bob::Engine::Threaded.new(5)
+      Bob.build(buildable, commit_id)
+      Bob.engine.wait!
+
+      status, output = buildable.builds[commit_id]
+      assert_equal :successful,          status
+      assert_equal "Running tests...\n", output
+
+      commit = buildable.metadata[commit_id]
+      assert_equal "This commit will work", commit[:message]
+      assert_equal Time.now.min,            commit[:committed_at].min
+    ensure
+      Bob.engine = old_engine
+    end
+  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, :buildable
+
+  def setup
+    Bob.logger = Logger.new("/dev/null")
+    Bob.engine = Bob::Engine::Foreground
+    Bob.directory = File.expand_path(File.dirname(__FILE__) + "/../tmp")
+
+    FileUtils.rm_rf(Bob.directory) if File.directory?(Bob.directory)
+  end
+end

data/test/scm/git_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobGitTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = GitRepo.new(:test_repo)
+    @repo.create
+
+    @buildable = BuildableStub.call(@repo)
+  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.build(commit_id)
+
+    status, output = buildable.builds[commit_id]
+    assert_equal :successful,          status
+    assert_equal "Running tests...\n", output
+
+    assert_equal 1, buildable.metadata.length
+
+    commit = buildable.metadata[commit_id]
+    assert_equal "This commit will work", commit[:message]
+    assert commit[:committed_at].is_a?(Time)
+  end
+
+  test "with a failed build" do
+    repo.add_failing_commit
+
+    commit_id = repo.commits.last[:identifier]
+
+    buildable.build(commit_id)
+
+    status, output = buildable.builds[commit_id]
+    assert_equal :failed,              status
+    assert_equal "Running tests...\n", output
+
+    assert_equal 1, buildable.metadata.length
+
+    commit = buildable.metadata[commit_id]
+    assert_equal "This commit will fail", commit[:message]
+    assert commit[:committed_at].is_a?(Time)
+  end
+
+  test "with multiple commits" do
+    2.times { repo.add_failing_commit }
+    commits = repo.commits.collect { |c| c[:identifier] }
+
+    buildable.build(commits)
+
+    assert_equal 2, commits.length
+    assert_equal 2, buildable.metadata.length
+    assert_equal 2, buildable.builds.length
+  end
+
+  test "can build the head of a repository" do
+    repo.add_failing_commit
+    repo.add_successful_commit
+
+    buildable.build(:head)
+
+    assert_equal 1, buildable.builds.length
+
+    status, output = buildable.builds[repo.head]
+    assert_equal :successful,          status
+    assert_equal "Running tests...\n", output
+  end
+end

data/test/scm/svn_test.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobSvnTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = SvnRepo.new(:test_repo)
+    @repo.create
+
+    @buildable = BuildableStub.call(@repo)
+  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.build("2")
+
+    assert_equal 1, buildable.metadata.length
+
+    status, output = buildable.builds["2"]
+    assert_equal :successful,          status
+    assert_equal "Running tests...\n", output
+
+    assert_equal 1, buildable.metadata.length
+
+    commit = buildable.metadata["2"]
+    assert commit[:committed_at].is_a?(Time)
+    assert_equal "This commit will work", commit[:message]
+  end
+
+  test "with a failed build" do
+    repo.add_failing_commit
+
+    buildable.build("2")
+
+    status, output = buildable.builds["2"]
+    assert_equal :failed,              status
+    assert_equal "Running tests...\n", output
+
+    assert_equal 1, buildable.metadata.length
+
+    commit = buildable.metadata["2"]
+    assert commit[:committed_at].is_a?(Time)
+    assert_equal "This commit will fail", commit[:message]
+  end
+
+  test "with multiple commits" do
+    repo.add_successful_commit
+    2.times { repo.add_failing_commit }
+
+    buildable.build(repo.commits.collect { |c| c[:identifier] })
+
+    assert_equal 3, buildable.metadata.length
+    assert_equal 3, buildable.builds.length
+  end
+
+  test "can build the head of a repository" do
+    repo.add_failing_commit
+    repo.add_successful_commit
+
+    buildable.build(:head)
+
+    assert_equal 1, buildable.builds.length
+
+    status, output = buildable.builds["3"]
+    assert_equal :successful,          status
+    assert_equal "Running tests...\n", output
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: integrity-bob
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- "Nicol\xC3\xA1s Sanguinetti"
+- Simon Rozet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-02 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: 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: sr-bob-test
+  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: []
+
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- bob.gemspec
+- lib/bob.rb
+- lib/bob/buildable.rb
+- lib/bob/builder.rb
+- lib/bob/engine.rb
+- lib/bob/engine/foreground.rb
+- lib/bob/engine/threaded.rb
+- lib/bob/scm.rb
+- lib/bob/scm/abstract.rb
+- lib/bob/scm/git.rb
+- lib/bob/scm/svn.rb
+- lib/core_ext/object.rb
+- test/bob_test.rb
+- test/engine/threaded_test.rb
+- test/helper.rb
+- test/scm/git_test.rb
+- test/scm/svn_test.rb
+has_rdoc: true
+homepage: http://integrityapp.com
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Bob builds!
+test_files: []
+