bob-the-builder 0.1 → 0.1.1

data/README.rdoc

@@ -1,52 +1,24 @@
 = Bob the Builder
 
-Given a Buildable object with the following public API:
-
-* <tt>buildable.kind</tt>
-
-  Should return a Symbol with whatever kind of repository the buildable's code is
-  in (:git, :svn, etc).
-
-* <tt>buildable.uri</tt>
-
-  Returns a string like "git://github.com/integrity/bob.git", pointing to the code
-  repository.
-
-* <tt>buildable.branch</tt>
-
-  What branch of the repository should we build?
-
-* <tt>buildable.build_script</tt>
-
-  Returns a string containing the build script to be run when "building".
-
-* <tt>buildable.start_building(commit_id)</tt>
-
-  `commit_id` is a String that contains whatever is appropriate for the repo type,
-  so it would be a SHA1 hash for git repos, or a numeric id for svn, etc. This is a
-  callback so the buildable can determine how long it takes to build. It doesn't
-  need to return anything.
-
-* <tt>buildable.finish_building(commit_id, build_status, build_output)</tt>
-
-  Callback for when the build finishes. It doesn't need to return anything. It will
-  receive a string with the commit identifier, a boolean for the build exit status
-  (true for successful builds, false fore failed ones) and a string with the build
-  output (both STDOUT and STDERR).
+Given a Buildable object with a determined API (described in it's documentation), 
+Bob will, when called like:
 
-  A successful build is one where the build script returns a zero status code.
+    Bob.build(buildable, commit_id) # or Bob.build(buildable, [commit_id, commit_id, ...])
 
-Bob will, when called like:
+or from your buildable (if you are using the Bob::Buildable mixin provided) as:
 
-    Bob.build(buildable, commit_id)
+    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>build_script</tt> in the buildable.
-4. When the build process finishes, it will call <tt>finish_building</tt> with
+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

data/Rakefile

@@ -7,7 +7,7 @@ rescue LoadError
 end
 
 begin
-  require "metric_fu"
+  require "metric_fu" if RUBY_VERSION < "1.9"
 rescue LoadError
 end
 

data/bob-the-builder.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = "bob-the-builder"
-  s.version = "0.1"
-  s.date    = "2009-05-05"
+  s.version = "0.1.1"
+  s.date    = "2009-05-08"
 
   s.description = "Bob the Builder will build your code. Simple."
   s.summary     = "Bob builds!"
@@ -33,14 +33,22 @@ bob-the-builder.gemspec
 lib/bob.rb
 lib/bob/background_engines.rb
 lib/bob/background_engines/foreground.rb
+lib/bob/background_engines/threaded.rb
 lib/bob/builder.rb
+lib/bob/buildable.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/background_engine/threaded_test.rb
 test/bob_test.rb
 test/helper.rb
-test/helper/git_helper.rb
+test/helper/abstract_scm_helper.rb
 test/helper/buildable_stub.rb
+test/helper/git_helper.rb
+test/helper/svn_helper.rb
+test/scm/git_test.rb
+test/scm/svn_test.rb
 ]
 end

data/lib/bob.rb

@@ -4,6 +4,7 @@ require "logger"
 require "time"
 require "addressable/uri"
 
+require "bob/buildable"
 require "bob/builder"
 require "bob/scm"
 require "bob/background_engines"

data/lib/bob/background_engines/threaded.rb

@@ -0,0 +1,108 @@
+require "thread"
+
+module Bob
+  module BackgroundEngines
+    class Threaded
+
+      def initialize(pool_size = 2)
+        @pool = ThreadPool.new(pool_size)
+      end
+
+      def call(job)
+        @pool << job
+      end
+
+      def njobs
+        @pool.njobs
+      end
+
+      def wait!
+        Thread.pass until @pool.njobs == 0
+      end
+
+      class ThreadPool
+        class Incrementor
+          def initialize(v = 0)
+            @m = Mutex.new
+            @v = v
+          end
+
+          def inc(v = 1)
+            sync { @v += v }
+          end
+
+          def dec(v = 1)
+            sync { @v -= v }
+          end
+
+          def inspect
+            @v.inspect
+          end
+
+          def to_i
+            @v
+          end
+
+          private
+
+          def sync(&b)
+            @m.synchronize &b
+          end
+        end
+
+        attr_reader :size, :jobs
+
+        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
+
+        def initialize(size = nil)
+          size ||= 2
+          @jobs    = Queue.new
+          @njobs   = Incrementor.new
+          @workers = Array.new(size) { spawn }
+        end
+
+        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
+
+        def njobs
+          @njobs.to_i
+        end
+
+        private
+
+        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/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 kind
+      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/scm/abstract.rb

@@ -35,8 +35,8 @@ module Bob
 
       protected
 
-      def run(command)
-        command = "(cd #{working_dir} && #{command} &>/dev/null)"
+      def run(command, cd_into_working_dir=true)
+        command = "(#{cd_into_working_dir ? "cd #{working_dir} && " : ""}#{command} &>/dev/null)"
         Bob.logger.debug command
         system(command) || raise(CantRunCommand, "Couldn't run SCM command `#{command}`")
       end

data/lib/bob/scm/git.rb

@@ -29,10 +29,8 @@ module Bob
       end
 
       def clone
-        git "clone #{uri} #{working_dir}"
-      rescue CantRunCommand
         FileUtils.rm_r working_dir
-        retry
+        run "git clone #{uri} #{working_dir}", false
       end
 
       def fetch
@@ -45,10 +43,6 @@ module Bob
         git "reset --hard #{commit_id}"
       end
 
-      def reset(commit_id)
-        git "reset --hard #{commit_id}"
-      end
-
       def git(command)
         run "git #{command}"
       end

data/lib/bob/scm/svn.rb

@@ -0,0 +1,46 @@
+require "bob/scm/abstract"
+
+module Bob
+  module SCM
+    class Svn < Abstract
+      def info(revision)
+        dump = %x[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 with_commit(commit_id)
+        update_code
+        checkout(commit_id)
+        yield
+      end
+
+    protected
+
+      def path_from_uri
+        "svn-#{uri.path[1..-1]}"
+      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/test/background_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 = GitBuildableStub.new(@repo)
+  end
+
+  test "with a successful threaded build" do
+    old_engine = Bob.engine
+
+    repo.add_successful_commit
+    commit_id = repo.commits.first[:identifier]
+
+    begin
+      Thread.abort_on_exception = true
+      Bob.engine = Bob::BackgroundEngines::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

@@ -16,9 +16,6 @@ require "git_helper"
 require "svn_helper"
 require "buildable_stub"
 
-Bob.logger = Logger.new("/dev/null")
-Bob.engine = Bob::BackgroundEngines::Foreground
-Bob.directory = File.expand_path(File.dirname(__FILE__) + "/../tmp")
 
 class Test::Unit::TestCase
   include Bob
@@ -27,6 +24,10 @@ class Test::Unit::TestCase
   attr_reader :repo, :buildable
 
   def setup
-    FileUtils.rm_rf(Bob.directory)
+    Bob.logger = Logger.new("/dev/null")
+    Bob.engine = Bob::BackgroundEngines::Foreground
+    Bob.directory = File.expand_path(File.dirname(__FILE__) + "/../tmp")
+
+    FileUtils.rm_rf(Bob.directory) if File.directory?(Bob.directory)
   end
 end

data/test/helper/abstract_scm_helper.rb

@@ -0,0 +1,50 @@
+module TestHelper
+  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 &>/dev/null"
+      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
+
+    protected
+      def add(file)
+        raise NotImplementedError
+      end
+
+      def commit(message)
+        raise NotImplementedError
+      end
+
+      def build_script(successful=true)
+        <<-script
+#!/bin/sh
+echo "Running tests..."
+exit #{successful ? 0 : 1}
+script
+      end
+  end
+end

data/test/helper/buildable_stub.rb

@@ -1,5 +1,7 @@
 module TestHelper
   module BuildableStub
+    include Bob::Buildable
+
     attr_reader :repo, :builds, :metadata
 
     def initialize(repo)

data/test/helper/git_helper.rb

@@ -17,7 +17,7 @@ module TestHelper
 
     def commits
       Dir.chdir(@path) do
-        commits = `git log --pretty=oneline`.collect { |l| l.split(" ").first }
+        commits = `git log --pretty=oneline`.each_line.collect { |l| l.split(" ").first }
         commits.inject([]) do |commits, sha1|
           format  = "---%n:message: >-%n  %s%n:timestamp: %ci%n" +
             ":identifier: %H%n:author: %n :name: %an%n :email: %ae%n"

data/test/helper/svn_helper.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + "/abstract_scm_helper"
+
+module TestHelper
+  class SvnRepo < AbstractSCMRepo
+    def self.server_root
+      @root ||= File.join(Bob.directory, "svn")
+    end
+
+    attr_reader :remote
+
+    def initialize(name, base_dir=Bob.directory)
+      super
+
+      @path   = File.join(base_dir, "svn-#{name}")
+      @remote = File.join(SvnRepo.server_root, name.to_s)
+    end
+
+    def create
+      create_remote
+
+      system "svn checkout file://#{remote} #{path} &>/dev/null"
+
+      add_commit("First commit") do
+        system "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) }
+        }
+      end
+    end
+
+    def head
+      commits.first[:identifier]
+    end
+
+    protected
+      def add(file)
+        system "svn add #{file} &>/dev/null"
+      end
+
+      def commit(message)
+        system %Q{svn commit -m "#{message}" &>/dev/null}
+        system "svn up &>/dev/null"
+      end
+
+    private
+      def create_remote
+        FileUtils.mkdir_p(SvnRepo.server_root)
+
+        system "svnadmin create #{remote} &>/dev/null"
+
+        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/scm/git_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobGitTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = GitRepo.new(:test_repo)
+    @repo.create
+
+    @buildable = GitBuildableStub.new(@repo)
+  end
+
+  test "with a successful build" do
+    repo.add_successful_commit
+
+    commit_id = repo.commits.first[: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.first[: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
+end

data/test/scm/svn_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class BobSvnTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @repo = SvnRepo.new(:test_repo)
+    @repo.create
+
+    @buildable = SvnBuildableStub.new(@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
+    commit_id = repo.commits.first[: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 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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bob-the-builder
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: 0.1.1
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-05 00:00:00 -03:00
+date: 2009-05-08 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,17 +80,27 @@ files:
 - lib/bob.rb
 - lib/bob/background_engines.rb
 - lib/bob/background_engines/foreground.rb
+- lib/bob/background_engines/threaded.rb
 - lib/bob/builder.rb
+- lib/bob/buildable.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/background_engine/threaded_test.rb
 - test/bob_test.rb
 - test/helper.rb
-- test/helper/git_helper.rb
+- test/helper/abstract_scm_helper.rb
 - test/helper/buildable_stub.rb
+- test/helper/git_helper.rb
+- test/helper/svn_helper.rb
+- test/scm/git_test.rb
+- test/scm/svn_test.rb
 has_rdoc: true
 homepage: http://integrityapp.com
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -111,9 +121,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: bob-the-builder
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Bob builds!
 test_files: []