heidi 0.3.1 → 0.4.0

data/lib/heidi/hook.rb

@@ -16,9 +16,11 @@ class Heidi
 
       start = Time.now
       env = {
+        'HEIDI_DIR'          => build.project.root,
         'HEIDI_LOG_DIR'      => build.log_root,
         'HEIDI_BUILD_DIR'    => where,
         'HEIDI_BUILD_COMMIT' => build.commit,
+        'HEIDI_BRANCH'       => build.project.branch,
 
         'RUBYOPT'         => nil,
         'BUNDLE_BIN_PATH' => nil,

data/lib/heidi/integrator.rb

@@ -42,14 +42,16 @@ class Heidi
 
       return failure if !run_hooks(:before)
 
+      # have a builder build the build dir
       builder = Heidi::Builder.new(build)
       return failure if !builder.build!
       return failure if !run_hooks(:build)
 
-      tester = Heidi::Tester.new(build)
+      # have a tester test the build
+      tester = Heidi::Tester.new(self)
       return failure if !tester.test!
-      return failure if !run_hooks(:tests)
 
+      # and run the success hooks
       return failure if !run_hooks(:success)
 
       # create a tarball
@@ -58,20 +60,24 @@ class Heidi
       return success
 
     rescue Exception => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace.join("\n")
+      build.log(:error, e.message)
+      build.log(:error, e.backtrace.join("\n"))
 
-      return $!
+      return e.message
 
     ensure
       run_hooks(:failure) if @failed == true
 
+      run_hooks(:after)
+
       # always unlock the build root, no matter what
       build.unlock
 
     end
 
     def run_hooks(where)
+      build.load_hooks if build.hooks.nil? || build.hooks.empty?
+
       return true if @hooks_ran.include?(where)
       return true if build.hooks[where].nil? || build.hooks[where].empty?
 

data/lib/heidi/project.rb

@@ -34,16 +34,17 @@ class Heidi
         end.first
       end
 
-      return @builds
+      return @builds.sort_by(&:time)
     end
 
     def name=(name)
-      @name = name
       @git["name"] = name
     end
 
     def name
-      @name ||= @git[:name]
+      name ||= @git[:name] || basename
+      name = basename if name.empty?
+      name
     end
 
     def basename
@@ -51,8 +52,9 @@ class Heidi
     end
 
     def commit
-      @git.commit[0..8]
+      @git.commit[0..7]
     end
+    alias_method :HEAD, :commit
 
     def author(commit=self.commit)
       @git.log(1, "%cN <%cE>", commit)
@@ -62,6 +64,10 @@ class Heidi
       @git.log(1, "%ci", commit)
     end
 
+    def message(commit=self.commit)
+      @git.log(1, "%B", commit)
+    end
+
     def last_commit
       @git["commit"]
     end
@@ -84,18 +90,18 @@ class Heidi
     end
 
     def build_status
-      @git["build.status"]
+      @git["build.status"] || "unknown"
     end
     def build_status=(status)
       @git["build.status"] = status
     end
 
-    def integration_branch
+    def branch
       name = @git["build.branch"]
       name == "" ? nil : name
     end
-    def integration_branch=(name)
-      name = name.split('/').last if name =~ /\//
+    def branch=(name)
+      name.gsub!("origin/", "")
       @git["build.branch"] = name
     end
 
@@ -104,10 +110,13 @@ class Heidi
     end
 
     def integrate(forced=false)
-      return true if !forced && self.current_build == self.commit
+      must_build = !(self.current_build == self.commit)
+      must_build = build_status != "passed"
+
+      return true if !forced && !must_build
       return "locked" if locked?
 
-      status = "unknown"
+      status = Heidi::DNF
 
       self.lock do
         record_current_build
@@ -117,7 +126,7 @@ class Heidi
         elsif res.is_a? String
           status = res
         else
-          status = "failed"
+          status = Heidi::FAILED
         end
       end
 
@@ -125,22 +134,26 @@ class Heidi
     end
 
     def fetch
-      if integration_branch && @git.branch != integration_branch
-        if @git.branches.include? integration_branch
-          @git.switch(integration_branch)
-          @git.merge "origin/#{integration_branch}"
+      return if locked?
 
-        else
-          @git.checkout(integration_branch, "origin/#{integration_branch}")
+      self.lock do
+        if branch && @git.branch != branch
+          if @git.branches.include? branch
+            @git.switch(branch)
+            @git.merge "origin/#{branch}"
+
+          else
+            @git.checkout(branch, "origin/#{branch}")
 
+          end
         end
-      end
 
-      @git.pull
+        @git.pull
 
-      # when the head has changed, update some stuff
-      if last_commit != self.commit
-        record_last_commit
+        # when the head has changed, update some stuff
+        if last_commit != self.commit
+          record_last_commit
+        end
       end
     end
 
@@ -155,8 +168,8 @@ class Heidi
       end
     end
 
-    def log
-      log = @git.graph(120)
+    def log(length=60)
+      log = @git.graph(length)
 
       lines = []
       log.out.lines.each do |line|

data/lib/heidi/shell.rb

@@ -0,0 +1,119 @@
+require 'heidi'
+require 'simple_shell'
+
+class Heidi
+  module Shell
+    def shell
+      @shell ||= SimpleShell.new
+    end
+
+    def check_heidi_root()
+      if !File.exists?("./projects")  && File.directory?("./projects")
+        $stderr.puts "You're not inside Heidi"
+        exit 1
+      end
+    end
+
+    def noisy
+      @noisy=true
+    end
+
+    def silent
+      @noisy=false
+    end
+
+    def shout(msg)
+      @noisy ||= false
+      return if @noisy == false
+      puts msg
+    end
+
+    def new_heidi_root(name)
+      shout "creating #{name}/"
+      shout "creating #{name}/projects"
+      shell.mkdir %W(-p #{name}/projects)
+      shell.mkdir %W(-p #{name}/bin)
+      shout "creating #{name}/Gemfile"
+      File.open("#{name}/Gemfile", File::CREAT|File::WRONLY) do |f|
+        f.puts 'source "http://rubygems.org"'
+        f.puts 'gem "heidi"'
+      end
+
+      shout "\nIf you like you can run: bundle install --binstubs"
+      shout "this will tie heidi and heidi_web to this location"
+      shout "\nFor even more tying down, run: bundle install --deployment"
+      shout "after running bundle install --binstubs"
+    end
+
+    def new_project(name, repo, branch="master")
+      if File.exists? "projects/#{name}"
+        $stderr.puts "projects/#{name} is in the way. Please remove it"
+        exit 1
+      end
+
+      # create a logs dir
+      shout "creating projects/#{name}"
+      shout "creating projects/#{name}/logs"
+      shell.mkdir %W(-p projects/#{name}/logs)
+
+      %w(build tests failure success before).each do |hook|
+        shout "creating projects/#{name}/hooks/#{hook}"
+        shell.mkdir %W(-p projects/#{name}/hooks/#{hook})
+      end
+
+      # make a clone
+      shell.in("projects/#{name}") do |sh|
+        shout "filling #{name} cache"
+
+        shout "git clone #{repo}"
+        sh.git %W(clone #{repo} cached)
+
+        sh.in("cached") do |cached|
+          shout "setting the name of the project to: #{name}"
+          cached.git %W(config heidi.name #{name})
+          shout "setting the branch to: #{branch}"
+          cached.git %W(config heidi.build.branch #{branch})
+        end
+      end
+
+      shout "Creating default test hook: projects/#{name}/hooks/tests/01_rspec"
+      File.open("projects/#{name}/hooks/tests/01_rspec", File::CREAT|File::WRONLY) do |f|
+        f.puts %q(#!/bin/sh
+
+# edit this file to your needs
+bundle exec rake spec
+)
+      end
+      shell.chmod %W(+x projects/#{name}/hooks/tests/01_rspec)
+      shout "\n"
+      shout "Now edit or add some hooks and run: heidi integrate #{name}"
+
+    end
+
+    def remove_project(name)
+      # remove build and cache dir, expose logs directly
+      shout "removing build dir"
+      shell.rm %W(-r projects/#{name}/build)
+      shout "removing cache (preserving project config)"
+      shell.cp %W(-pr projects/#{name}/cached/.git/config projects/#{name})
+      shell.rm %W(-r projects/#{name}/cached)
+      shout "exposing builds"
+      shell.mv %W(projects/#{name}/logs/* projects/#{name}/)
+      shell.rm %W(-r projects/#{name}/logs)
+    end
+
+    def integrate(name)
+      heidi = Heidi.new
+      heidi.projects.each do |project|
+        next if !name.nil? && project.name != name
+
+        project.fetch
+        msg = project.integrate(!name.nil?)
+        unless msg.nil? || msg == true
+          $stderr.puts "#{project.name}: #{msg}"
+        end
+      end
+    end
+
+  end
+end

data/lib/heidi/tester.rb

@@ -2,10 +2,11 @@ class Heidi
   class Tester
     attr_reader :build, :project, :message
 
-    def initialize(build)
-      @build    = build
-      @project  = build.project
-      @message  = ""
+    def initialize(integrator)
+      @integrator = integrator
+      @build      = integrator.build
+      @project    = @build.project
+      @message    = ""
     end
 
     def test!
@@ -17,7 +18,7 @@ class Heidi
         return false
       end
 
-      return true
+      return @integrator.run_hooks(:tests)
     end
 
   end

data/lib/heidi/web.rb

@@ -1,5 +1,6 @@
 require 'sinatra/base'
 require 'heidi'
+require 'heidi/shell'
 require 'simple_shell'
 
 class Heidi
@@ -16,6 +17,7 @@ class Heidi
 
     before {
       @heidi = Heidi.new(self.class.project_path)
+      @crumbs = []
     }
 
     dir = File.dirname(File.expand_path(__FILE__))
@@ -23,15 +25,33 @@ class Heidi
     set :sessions, true
 
     set :views,  "#{dir}/web/views"
-    set :public_folder, "#{dir}/web/public"
+    set :public_folder, "#{dir}/web/assets"
     set :root, dir
 
     get '/' do
-      redirect '/projects/', 302
+      @crumbs = [ { 'home' => ''} ]
+      erb(:home, { :locals => { :projects => @heidi.projects }})
     end
 
     get '/projects/' do
-      erb(:home, { :locals => { :projects => @heidi.projects }})
+      @crumbs = [ { 'home' => '/'}, { 'new project' => '' } ]
+      erb(:new_project)
+    end
+
+    post '/projects/' do
+      basename = params[:name].downcase.gsub(/\W/,'_')
+
+      Thread.new(basename) do |name|
+        worker = Class.new
+        worker.extend(Heidi::Shell)
+        worker.silent
+
+        worker.new_project(name, params[:origin], params[:branch])
+      end
+
+      sleep 1
+
+      redirect "/projects/#{basename}", 302
     end
 
     get '/projects/:name' do
@@ -43,6 +63,19 @@ class Heidi
       erb(:project, { :locals => { :project => project }})
     end
 
+    get '/projects/:name/fetch' do
+      project = @heidi[params[:name]]
+      if project.nil?
+        return "no project by that name: #{params[:name]}"
+      end
+
+      Thread.new { project.fetch && project.integrate() }
+
+      sleep 1
+
+      redirect "/projects/#{project.basename}", 302
+    end
+
     get '/projects/:name/build/:commit' do
       project = @heidi[params[:name]]
       if project.nil?
@@ -117,7 +150,7 @@ class Heidi
       end
 
       project.name = params[:name]
-      project.integration_branch = params[:branch]
+      project.branch = params[:branch]
 
 
       redirect "/projects/#{project.basename}", 302
@@ -137,6 +170,34 @@ class Heidi
             "<span class=\"#{classes.join(" ")}\">"
           end
       end
+
+      def breadcrumbs
+        ""
+      end
+
+      def status2alert(status)
+        case status
+        when "passed"
+          "alert-success"
+        when "failed"
+          "alert-error"
+        else
+          ""
+        end
+      end
+
+      def status2label(status)
+        case status
+        when "passed"
+          "label-success"
+        when "failed"
+          "label-important"
+        else
+          "label-info"
+        end
+      end
+
+
     end
   end
 end