heidi 0.0.1

data/lib/heidi/git.rb

@@ -0,0 +1,113 @@
+require 'fileutils'
+require 'simple_shell'
+require 'strscan'
+
+class Heidi
+
+  # A very simple interface to git base on SimpleShell, no library ties and no
+  # fancy stuff
+  #
+  class Git
+    VERBOSE=false
+
+    def initialize(path=Dir.pwd, verbose=VERBOSE)
+      @path = path
+      SimpleShell.noisy = verbose
+      @shell = SimpleShell.new(@path)
+    end
+
+    # get the latest commit hash
+    def commit
+      res = @shell.git "log", "-n", "1", "--pretty=%H"
+      res.out
+    end
+    alias_method :HEAD, :commit
+    alias_method :head, :commit
+
+    # find the current branch (the one with the *)
+    def branch
+      res = @shell.git "branch", "--no-color"
+      active = res.out.scan(/\* \w+/).first
+      active.scan(/\w+$/).first
+    end
+
+    # git branch
+    def branches
+      res = @shell.git "branch", "--no-color"
+      res.out.split("\n").collect{ |b| b.gsub(/^[\s*]+/, '') }
+    end
+
+    # git checkout $name
+    def switch(name)
+      return nil unless branches.include?(name)
+      @shell.git "checkout", name
+    end
+
+    # git checkout -b $name [$base]
+    def checkout(name, base=nil)
+      command = [ "git", "checkout", "-b", name ]
+      command << base unless base.nil?
+      @shell.system(*command)
+    end
+
+    # git merge $base
+    def merge(base)
+      @shell.git %W(merge #{base})
+    end
+
+    # git fetch $where='origin'
+    def fetch(where="origin")
+      @shell.git %W(fetch #{where})
+    end
+
+    # git pull $where='origin' [$what]
+    def pull(where="origin", what=nil)
+      command = [ "git", "pull", where ]
+      command << what if !what.nil?
+
+      @shell.system(*command)
+    end
+
+    # git push $where [$what]
+    #
+    #   $what may be '--tags'
+    #
+    def push(where="origin", what=nil)
+      command = [ "git", "push", where ]
+      if !what.nil?
+        if what == "--tags"
+          command.insert(2, what)
+        else
+          command << what
+        end
+      end
+
+      @shell.system(*command)
+    end
+
+    # git tags
+    def tags
+      res = @shell.system("git", "tag")
+      res.out.split("\n")
+    end
+
+    # git tag -a -m $message $name
+    def tag(name, message)
+      command = [ "git", "tag", "-a", "-m", message, name ]
+      if tags.include?(name)
+        command.insert(4, "-f")
+      end
+      @shell.system(*command)
+    end
+
+    # git config $key $value
+    def []=(key, value)
+      @shell.system("git", "config", "heidi.#{key}", value)
+    end
+
+    # git config $key
+    def [](key)
+      @shell.system("git", "config", "heidi.#{key}").out
+    end
+  end
+end

data/lib/heidi/hook.rb

@@ -0,0 +1,20 @@
+require 'simple_shell'
+
+class Heidi
+  class Hook
+    def initialize(project, script)
+      @project = project
+      @script  = script
+    end
+
+    def perform(where)
+      shell = SimpleShell.new(where)
+      res = shell.do @script
+      return res
+    end
+
+    def name
+      File.basename(@script)
+    end
+  end
+end

data/lib/heidi/integrator.rb

@@ -0,0 +1,84 @@
+require 'heidi/build'
+require 'heidi/builder'
+require 'heidi/tester'
+require 'time'
+
+class Heidi
+  class Integrator
+    attr_reader :build, :project
+
+    def initialize(project)
+      @project = project
+      @build   = Heidi::Build.new(project)
+      @failed  = false
+    end
+
+    def failure
+      @failed = true
+      build.record(:failure)
+    end
+
+    def integrate
+      start = Time.now
+      build.lock
+      build.load_hooks
+      build.clean
+
+      return failure if !run_hooks(:before)
+
+      builder = Heidi::Builder.new(build)
+      tester = Heidi::Tester.new(build)
+
+      return failure if !builder.build!
+      return failure if !tester.test!
+      return failure if !run_hooks(:after)
+
+      # record the new succesful
+      build.record(:success)
+
+      # create a tarball
+      build.create_tar_ball
+
+      build.log :info, ("Integration took: %.2fs" % (Time.now - start))
+      return true
+
+    rescue Exception => e
+      $stderr.puts e.message
+      $stderr.puts e.backtrace.join("\n")
+
+      return $!
+
+    ensure
+      run_hooks(:failed) if @failed == true
+
+      # always unlock the build root, no matter what
+      build.unlock
+
+      return @failed == true ? false : true
+
+    end
+
+    def run_hooks(where)
+      return true if build.hooks[where].nil? || build.hooks[where].empty?
+
+      hooks_failed = false
+      build.hooks[where].each do |hook|
+        res = hook.perform(build.build_root)
+
+        if res.S?.to_i != 0
+          build.log :error, "--- #{where} hook: #{hook.name} failed ---"
+          build.log :error, res.err
+
+          hooks_failed = true
+          break
+
+        else
+          build.log :info, res.out
+        end
+      end
+
+      return hooks_failed == true ? false : true
+    end
+
+  end
+end

data/lib/heidi/project.rb

@@ -0,0 +1,113 @@
+require 'heidi/git'
+require 'heidi/integrator'
+require 'heidi/hook'
+require 'time'
+
+class Heidi
+  class Project
+    attr_reader :root, :cached_root, :lock_file, :builds
+
+    def initialize(root)
+      @root        = root
+      @lock_file   = File.join(root, ".lock")
+      @cached_root = File.join(root, "cached")
+      @git         = Heidi::Git.new(@cached_root)
+      load_builds
+    end
+
+    def load_builds
+      @builds = []
+      Dir[File.join(root, "logs", "*")].each do |build|
+        next unless File.directory? build
+        @builds << Heidi::Build.new(self, File.basename(build))
+      end
+    end
+
+    def name=(name)
+      @name = name
+      @git["name"] = name
+    end
+
+    def name
+      @name ||= @git[:name]
+    end
+
+    def commit
+      @git.commit[0..8]
+    end
+
+    def last_commit
+      @git["commit"]
+    end
+    def record_last_commit
+      @git["commit"] = self.commit
+    end
+
+    def latest_build
+      @git["build.latest"]
+    end
+    def record_latest_build
+      @git["build.latest"] = self.commit
+    end
+
+    def build_status
+      @git["build.status"]
+    end
+    def build_status=(status)
+      @git["build.status"] = status
+    end
+
+    def integration_branch
+      name = @git["build.branch"]
+      name == "" ? nil : name
+    end
+
+    def integrate
+      return "locked" if locked?
+
+      status = ""
+      self.lock do
+        res = Heidi::Integrator.new(self).integrate
+        status = res != true ? "failed" : "passed"
+      end
+
+      return status
+    end
+
+    def fetch
+      @git.fetch
+      if integration_branch
+        if @git.branches.include? integration_branch
+          @git.switch(integration_branch)
+          @git.merge "origin/#{integration_branch}"
+
+        else
+          @git.checkout(integration_branch, "origin/#{integration_branch}")
+
+        end
+      end
+
+      record_last_commit
+    end
+
+    def lock(&block)
+      File.open(lock_file, File::TRUNC|File::CREAT|File::WRONLY) do |f|
+        f.puts Time.now.strftime("%c")
+      end
+
+      if block_given?
+        yield
+        self.unlock
+      end
+    end
+
+    def unlock
+      File.unlink lock_file
+    end
+
+    def locked?
+      File.exists? lock_file
+    end
+
+  end
+end

data/lib/heidi/tester.rb

@@ -0,0 +1,52 @@
+class Heidi
+  class Tester
+    attr_reader :build, :project, :message
+
+    def initialize(build)
+      @build    = build
+      @project  = build.project
+      @message  = ""
+    end
+
+    def test!
+      build.log(:info, "Starting tests")
+
+      tests_failed = false
+
+      if build.hooks[:tests].empty?
+        build.log(:error, "There are no test hooks")
+        @message = "There are no test hooks"
+        return false
+      end
+
+      build.hooks[:tests].each do |hook|
+        res = hook.perform(build.build_root)
+
+        if res.S?.to_i != 0
+          log "--- test #{hook.name} failed ---"
+          log res.err
+
+          @message = "tests failed"
+          tests_failed = true
+          break
+
+        else
+          log res.out
+        end
+      end
+
+      return tests_failed ? false : true
+    end
+
+    def log(string)
+      File.open(
+        File.join(build.root, "test.log"),
+        File::CREAT|File::WRONLY|File::APPEND
+      ) do |f|
+        f.puts string
+      end
+    end
+
+
+  end
+end

data/lib/heidi/web/routes/home.rb

@@ -0,0 +1,9 @@
+class Heidi; module Web; module Routes
+
+  module Home
+    get '/' do
+      '<h1>Welcome to Heidi!</h1>Psst. Want to see my <a href="/projects">projects</a>?'
+    end
+  end
+
+end; end; end

data/lib/heidi/web/routes/projects.rb

@@ -0,0 +1,61 @@
+class Heidi; module Web; module Routes
+
+  module Projects
+    get '/projects' do
+      output = ""
+      $heidi.projects.each do |project|
+        output += "<a href='/projects/#{project.name}'>#{project.name}</a><br />"
+      end
+
+      output
+    end
+
+    get '/projects/:name' do
+      project = $heidi[params[:name]]
+      if project.nil?
+        return "no project by that name: #{params[:name]}"
+      end
+
+      output = "<h1>#{project.name}</h1>"
+      output += "Build status: #{project.build_status}"
+      output += "<br /><br /><h2>Build history</h2>"
+      project.builds.each do |build|
+        output += %Q{<a href="/projects/#{project.name}/build/#{build.commit}">#{build.commit}</a> - #{build.status}<br />}
+      end
+
+      output
+    end
+
+    get '/projects/:name/build/:commit' do
+      project = $heidi[params[:name]]
+      if project.nil?
+        return "no project by that name: #{params[:name]}"
+      end
+
+      # load build of project
+      build = Heidi::Build.new(project, params[:commit])
+      output = "<h1>#{project.name}</h1>"
+      output += "<h2>Build: #{build.commit} - #{build.status}<h2>"
+
+      %w(heidi.info heidi.errors build.log test.log).each do |log_file|
+        log = build.logs(log_file)
+        if (!log.nil? and !log.empty?)
+          output += "<h3>#{log_file}</h3>"
+          output += "<pre>#{log}</pre>"
+        end
+      end
+
+      output
+    end
+
+    put '/projects/:name/build' do
+      project = $heidi[params[:name]]
+      if project.nil?
+        return "no project by that name: #{params[:name]}"
+      end
+
+      project.integrate
+    end
+  end
+
+end; end; end

data/lib/heidi/web/routes.rb

@@ -0,0 +1,13 @@
+require 'heidi/web/routes/projects'
+require 'heidi/web/routes/home'
+
+class Heidi
+  module Web
+    module Routes
+      def self.included(base)
+        base.extend Routes::Home
+        base.extend Routes::Projects
+      end
+    end
+  end
+end

data/lib/heidi/web.rb

@@ -0,0 +1,8 @@
+require 'sinatra'
+require 'heidi/web/routes'
+
+class Heidi
+  module Web
+    SimpleShell.noisy = true
+  end
+end

data/lib/heidi.rb

@@ -0,0 +1,25 @@
+require 'fileutils'
+require 'simple_shell'
+
+require 'heidi/project'
+
+class Heidi
+  attr_reader :projects
+
+  def initialize(root=Dir.pwd)
+    @root = root
+    @projects = []
+    Dir[File.join(root,"projects", "*")].each do |project|
+      next unless File.directory?(project)
+
+      @projects << Heidi::Project.new(project)
+    end
+  end
+
+  def [](name)
+    name = "#{name}"
+    @projects.select do |project|
+      project.name == name || File.basename(project.root) == name
+    end.first
+  end
+end

data/spec/heidi/build_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Build do
+  pending "more tests please!"
+end

data/spec/heidi/builder_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Builder do
+  pending "more tests please!"
+end

data/spec/heidi/git_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Heidi::Git do
+  let(:git) { Heidi::Git.new() }
+
+  it "should can find the HEAD" do
+    git.commit.should_not be_empty
+    git.commit.should == git.HEAD
+  end
+
+  it "should list all branches" do
+    git.branches.should be_kind_of(Array)
+  end
+
+  it "should list the current branch" do
+    git.branch.should_not be_empty
+    git.branch.should_not =~ /^\*/
+  end
+
+  it "should list the tags" do
+    git.tags.should be_kind_of(Array)
+  end
+
+  describe "config" do
+    let(:random) { "#{rand(1000)}.#{rand(1000)}" }
+
+    it "should write configs" do
+      git["test.entry"].should_not == random
+      git["test.entry"] = random
+    end
+
+    it "should read configs" do
+      git["test.entry"].should_not == be_empty
+    end
+  end
+end

data/spec/heidi/hook_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Hook do
+  pending "more tests please!"
+end

data/spec/heidi/integrator_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Integrator do
+  pending "more tests please!"
+end

data/spec/heidi/project_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Project do
+  pending "more tests please!"
+end

data/spec/heidi/tester_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Heidi::Tester do
+  pending "more tests please!"
+end

data/spec/heidi/web_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'heidi/web'
+
+describe Heidi::Web do
+  pending "more tests please!"
+end

data/spec/heidi_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Heidi do
+  before(:all) do
+    shell = SimpleShell.new("/")
+    shell.mkdir("-p", "/tmp/heidi_spec/projects/one")
+  end
+
+  it "should gather projects on load" do
+    h = Heidi.new("/tmp/heidi_spec")
+    h.projects.should be_kind_of(Array)
+    h.projects.count.should == 1
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'heidi'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end