bob-the-builder 0.1

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,58 @@
+= 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).
+
+  A successful build is one where the build script returns a zero status code.
+
+Bob will, when called like:
+
+    Bob.build(buildable, 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
+   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).
+
+== 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,43 @@
+require "rake/testtask"
+
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
+
+begin
+  require "metric_fu"
+rescue LoadError
+end
+
+begin
+  require "mg"
+  MG.new("bob-the-builder.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/background_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
+}
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.title = "Documentation for Bob the Builder"
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
+  rd.rdoc_dir = "doc"
+end

data/bob-the-builder.gemspec

@@ -0,0 +1,46 @@
+Gem::Specification.new do |s|
+  s.name    = "bob-the-builder"
+  s.version = "0.1"
+  s.date    = "2009-05-05"
+
+  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 = "bob-the-builder"
+  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 "contest"
+    s.add_development_dependency "redgreen"
+    s.add_development_dependency "ruby-debug"
+  end
+
+  s.files = %w[
+.gitignore
+LICENSE
+README.rdoc
+Rakefile
+bob-the-builder.gemspec
+lib/bob.rb
+lib/bob/background_engines.rb
+lib/bob/background_engines/foreground.rb
+lib/bob/builder.rb
+lib/bob/scm.rb
+lib/bob/scm/abstract.rb
+lib/bob/scm/git.rb
+lib/core_ext/object.rb
+test/bob_test.rb
+test/helper.rb
+test/helper/git_helper.rb
+test/helper/buildable_stub.rb
+]
+end

data/lib/bob.rb

@@ -0,0 +1,41 @@
+require "fileutils"
+require "yaml"
+require "logger"
+require "time"
+require "addressable/uri"
+
+require "bob/builder"
+require "bob/scm"
+require "bob/background_engines"
+
+module Bob
+  # Builds the specified <tt>buildable</tt>. This object must understand
+  # the API described in the README.
+  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 || BackgroundEngines::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/bob/background_engines.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 BackgroundEngines
+    autoload :Foreground, "bob/background_engines/foreground"
+    autoload :Threaded, "bob/background_engines/threaded"
+  end
+end

data/lib/bob/background_engines/foreground.rb

@@ -0,0 +1,6 @@
+module Bob
+  module BackgroundEngines
+    # Dummy engine that just runs in the foreground (useful for tests).
+    Foreground = lambda {|b| b.call }
+  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, :commit_id
+
+    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.kind} repo at #{buildable.uri}"
+      in_background do
+        scm.with_commit(commit_id) do
+          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
+    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.working_dir} && #{buildable.build_script} 2>&1)"
+    end
+
+    def scm
+      @scm ||= SCM.new(buildable.kind, buildable.uri, buildable.branch)
+    end
+
+    def in_background(&block)
+      Bob.engine.call(block)
+    end
+  end
+end

data/lib/bob/scm.rb

@@ -0,0 +1,23 @@
+require "bob/scm/abstract"
+
+module Bob
+  module SCM
+    autoload :Git, "bob/scm/git"
+    autoload :Svn, "bob/scm/svn"
+
+    class CantRunCommand < RuntimeError; end
+
+    # Factory to return appropriate SCM instances (according to repository kind)
+    def self.new(kind, uri, branch)
+      class_for(kind).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

@@ -0,0 +1,49 @@
+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_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
+      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}`")
+      end
+
+      def path_from_uri
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/bob/scm/git.rb

@@ -0,0 +1,57 @@
+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
+
+      protected
+
+      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}"
+      end
+
+      private
+
+      def update_code
+        cloned? ? fetch : clone
+      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
+
+      def git(command)
+        run "git #{command}"
+      end
+    end
+  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/helper.rb

@@ -0,0 +1,32 @@
+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 "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
+  include TestHelper
+
+  attr_reader :repo, :buildable
+
+  def setup
+    FileUtils.rm_rf(Bob.directory)
+  end
+end

data/test/helper/buildable_stub.rb

@@ -0,0 +1,55 @@
+module TestHelper
+  module BuildableStub
+    attr_reader :repo, :builds, :metadata
+
+    def initialize(repo)
+      @repo     = repo
+      @builds   = {}
+      @metadata = {}
+    end
+
+    def build_script
+      "./test"
+    end
+
+    def start_building(commit_id, commit_info)
+      @metadata[commit_id] = commit_info
+    end
+
+    def finish_building(commit_id, status, output)
+      @builds[commit_id] = [status ? :successful : :failed, output]
+    end
+  end
+
+  class GitBuildableStub
+    include BuildableStub
+
+    def kind
+      :git
+    end
+
+    def uri
+      repo.path
+    end
+
+    def branch
+      "master"
+    end
+  end
+
+  class SvnBuildableStub
+    include BuildableStub
+
+    def kind
+      :svn
+    end
+
+    def uri
+      "file://#{SvnRepo.server_root}/#{repo.name}"
+    end
+
+    def branch
+      ""
+    end
+  end
+end

data/test/helper/git_helper.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/abstract_scm_helper"
+
+module TestHelper
+  class GitRepo < AbstractSCMRepo
+    def create
+      FileUtils.mkdir_p @path
+
+      Dir.chdir(@path) do
+        system 'git init &>/dev/null'
+        system 'git config user.name "John Doe"'
+        system 'git config user.email "johndoe@example.org"'
+        system 'echo "just a test repo" >> README'
+        add    'README &>/dev/null'
+        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  = "---%n:message: >-%n  %s%n:timestamp: %ci%n" +
+            ":identifier: %H%n:author: %n :name: %an%n :email: %ae%n"
+          commits << YAML.load(`git show -s --pretty=format:"#{format}" #{sha1}`)
+        end
+      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)
+        system "git add #{file}"
+      end
+
+      def commit(message)
+        system %Q{git commit -m "#{message}" &>/dev/null}
+      end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: bob-the-builder
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- "Nicol\xC3\xA1s Sanguinetti"
+- Simon Rozet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-05 00:00:00 -03: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: 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-the-builder.gemspec
+- lib/bob.rb
+- lib/bob/background_engines.rb
+- lib/bob/background_engines/foreground.rb
+- lib/bob/builder.rb
+- lib/bob/scm.rb
+- lib/bob/scm/abstract.rb
+- lib/bob/scm/git.rb
+- lib/core_ext/object.rb
+- test/bob_test.rb
+- test/helper.rb
+- test/helper/git_helper.rb
+- test/helper/buildable_stub.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: bob-the-builder
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Bob builds!
+test_files: []
+