rbuilder 0.0.1

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+ desc 'Running all unit tests'
+ task :default => :test
+ task :test do
+    test_files = ['tests/**/test*.rb', 'tests/test*.rb']
+    test_files.each do |file_set|
+        Dir[file_set].each do |testfile| 
+            require testfile
+        end
+    end
+ end
+ 
+ desc 'Measures test coverage'
+ task :coverage do
+     rm_f "coverage"
+     rm_f "coverage.data"
+     rcov = "rcov --aggregate coverage.data"
+     system("#{rcov} --html tests/test*.rb")
+     system("#{rcov} --html tests/**/test*.rb")
+ end
+ 
+ 
+ spec = Gem::Specification.new do |s| 
+  s.name = "rbuilder"
+  s.version = "0.0.1"
+  s.author = "Rob Westgeest"
+  s.email = "rob.westgeest@gmail.com"
+  s.homepage = "http://notaresource.blogspot.com/rbuilder"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A Ruby auto build tool like build-o-matic for running on a desktop pc"
+  s.files = FileList["Rakefile", "conf/example.conf", "{bin}/*","{rbuilder}/**/*"].to_a
+  s.test_files = FileList["{tests}/test*.rb","{tests}/**/test_*.rb"].to_a
+  s.has_rdoc = true
+  s.require_path = 'rbuilder'
+  s.executables << 'rbuilder'
+  s.add_dependency("mocha", ">= 0.5.5")
+end
+ 
+Rake::GemPackageTask.new(spec) do |pkg| 
+  rm_f "pkg"
+  pkg.need_tar = true 
+end 
+
+ 

data/bin/rbuilder

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+$: << File.join(File.expand_path(File.dirname(__FILE__)),'..','rbuilder')
+require 'libs'
+require 'gui'
+require 'optparse'
+
+USAGE_MESSAGE = %Q{
+usage #{$0} <working_dir> <build_command>
+
+This program is an automatic builder for any build environment 
+(ant, make, rake... the lot). It accepts parameters for the 
+working directory and the build command. It assumes that the 
+working directory is a check-out of the archive that you are 
+working on and that the environment is subversion. It uses 
+svn commandline commands to get information on the archive and to poll
+wether anything has changed in the archive.
+
+If the subversion archive has been changed, a build will start 
+and reported in the gui of this program. The build command will 
+be executed in the working directory (i.e. probably the root of 
+your archive where the build files are expected to reside). 
+Your command would probably just be something simple like 'rake' 
+or 'make' or 'ant' but can be anything.
+
+The build command is expected to have an exit value of 0 when 
+the build is successfull and anything else when the build is 
+not successfull.
+}
+
+def usage 
+    puts USAGE_MESSAGE
+    exit(1)
+end
+    
+configuration_file = nil
+parser = OptionParser.new do |opts|
+    opts.banner = USAGE_MESSAGE
+    opts.on("-h", '--help', "show this message") { usage }
+    opts.on("-c", '--configfile file', "use configuration file ") { |file| configuration_file = file }
+end 
+    
+rest = parser.parse ARGV
+usage unless configuration_file || (rest[0] && rest[1])
+
+builder = Builder.new
+build_configuration = BuildConfiguration.new(builder)
+ 
+if configuration_file 
+    build_configuration.from_file(configuration_file)
+else
+    working_dir  = rest[0]
+    build_command = rest[1]
+    build_configuration.build(working_dir, build_command)
+end
+ 
+list_view = Gui::BuilderListView.new(builder)
+details_pane = Gui::BuildDetailsPane.new(Build.new(nil,nil,nil))
+view = Gui::BuilderMonitorWindow.new(builder,list_view,details_pane)
+view.show
+    
+Thread.start do  
+    builder.run
+end
+Gtk.main
+    

data/conf/example.conf

@@ -0,0 +1,2 @@
+build '../../integration_tests/some_project', 'rake'
+build '../../integration_tests/rbuilder', 'rake'

data/rbuilder/build.rb

@@ -0,0 +1,50 @@
+require 'lib/observer'
+require 'build_report'
+class Build
+    include Observable
+    
+    attr_reader :reason, :report, :archive
+    
+    def initialize(build_command, working_dir, reason, archive = '')
+        @build_command = build_command
+        @working_dir = working_dir
+        @reason = reason
+        @report = BuildReport.new
+        @archive = archive
+    end
+    
+    def run
+        self.building=true
+        report.info("running build with reason #{reason}\n")
+        build_command.execute(working_dir, report)
+        self.building=false
+    end
+    
+    def status
+        return building && BuildStatus.building || report.status
+    end
+
+    def summary
+        return building && reason.to_s || report.summary
+    end
+    
+    def building=(value)
+        @building=value  
+        changed!
+    end
+    
+    def revision 
+        return reason.revision
+    end
+    
+    def committer 
+        return reason.committer
+    end
+    
+    def green?  
+        status == BuildStatus.ok
+    end
+    
+    private
+    attr_reader :build_command, :working_dir, :building
+end

data/rbuilder/build_command.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+class BuildCommand
+    include FileUtils
+    def initialize(commandline)
+        @commandline = commandline
+    end
+    
+    def execute(working_dir, build_result)
+        cd working_dir do 
+            if run_command(build_result)
+                build_result.green
+            else
+                build_result.red
+            end
+        end
+    end
+    
+    def run_command(build_result)
+        puts "running '#{commandline}' in working dir '#{`pwd`.strip}'"
+        IO.popen commandline do |stdout|
+            while !stdout.eof?
+                line = stdout.readline
+                build_result.info(line)
+                puts line
+            end
+        end
+        return $? == 0
+    end
+        
+    private 
+    attr_reader :commandline
+    
+end

data/rbuilder/build_configuration.rb

@@ -0,0 +1,21 @@
+require 'source_control'
+require 'build_description'
+require 'build_command'
+
+class BuildConfiguration
+    def initialize(builder)
+        @builder = builder
+    end
+    
+    def build(dir, command)
+        @builder.add_description BuildDescription.new(BuildCommand.new(command), SourceControl.svn(dir))
+    end
+    
+    def from_text(text) 
+        instance_eval(text)
+    end
+    
+    def from_file(file)
+        from_text(File.read(file))
+    end
+end

data/rbuilder/build_description.rb

@@ -0,0 +1,46 @@
+require 'build_status'
+require 'revision_committed'
+
+class BuildDescription
+    include Observable
+    attr_reader :builds
+    
+    def initialize(build_command, source_control)
+        @build_command = build_command
+        @builds = []
+        @source_control = source_control
+    end
+    
+    def status
+        return BuilderState.ok if builds.empty? || builds.last.green?
+        return BuilderState.broken 
+    end
+
+    def run_build(reason)
+        build = create_build(reason)
+        changed!(:new_build => build)
+        build.run
+        builds << build 
+    end
+    
+    def new_revision_committed(source_control_status)
+        run_build(RevisionCommitted.from_source_control_status(source_control_status))
+    end
+    
+    def create_build(reason)
+        Build.new(build_command, working_dir, reason, source_control.archive)
+    end
+    
+    def iterate
+        source_control.report_change_to(self)
+    end
+    
+    private
+    
+    def working_dir
+        source_control.working_dir
+    end
+    
+    attr_reader :build_command, :source_control
+    
+end

data/rbuilder/build_report.rb

@@ -0,0 +1,40 @@
+require 'lib/observer'
+class BuildReport
+    include Observable
+    attr_reader :status
+    
+    def initialize(status = BuildStatus.ok)
+        @status = status
+        @loglines = []
+    end
+    
+    def green
+        self.status = BuildStatus.ok
+    end
+    
+    def red
+        self.status = BuildStatus.failed
+    end
+    
+    def status=(new_value)
+        @status = new_value
+        changed!
+    end
+    
+    def info(line_of_output)
+        line_of_output = line_of_output.strip
+        loglines << line_of_output
+        changed! :log_line => line_of_output
+    end
+    
+    def summary 
+        loglines.last || ''
+    end
+        
+    def log
+        loglines.join("\n")
+    end
+    
+    private 
+    attr_reader :loglines
+end

data/rbuilder/build_status.rb

@@ -0,0 +1,39 @@
+    class BuilderState
+        def initialize(value)
+            @value = value
+        end
+        @@broken = BuilderState.new('broken')
+        @@ok = BuilderState.new('ok')
+        
+        def self.broken
+            return @@broken
+        end
+        
+        def self.ok
+            return @@ok
+        end
+        
+        def to_s
+            @value
+        end
+        alias_method :inspect, :to_s
+    end
+    
+    class BuildStatus
+        def initialize(value)
+            @value = value
+        end
+        @@ok = BuildStatus.new('ok')
+        @@failed = BuildStatus.new('failed')
+        @@building = BuildStatus.new('building')
+        
+        def self.ok; return @@ok; end
+        def self.failed; return @@failed; end
+        def self.building; return @@building; end
+        
+        def to_s
+            @value
+        end
+        alias_method :inspect, :to_s
+    end
+    

data/rbuilder/builder.rb

@@ -0,0 +1,45 @@
+require 'lib/observer'
+require 'build_description'
+
+class Builder
+    include Observable
+    
+    attr_reader :descriptions
+    def initialize
+        @descriptions = []
+    end
+    
+    def add_description(build_description)
+        descriptions << build_description
+    end
+    
+    def each_description(&block)
+        descriptions.each(&block)
+    end
+    
+    def iterate
+        descriptions.each {|description| iterate_description(description)}
+    end
+    
+    def iterate_description(desc)
+        desc.iterate
+        changed!
+    end
+    
+    def run 
+        while true
+            begin  
+                iterate
+            rescue Exception => e
+                puts e.to_s
+            end
+            sleep(5)
+        end 
+    end 
+    
+    def status
+        descriptions.each {|description| return BuilderState.broken if description.status == BuilderState.broken}
+        return BuilderState.ok
+    end
+end
+

data/rbuilder/gui.rb

@@ -0,0 +1,6 @@
+require 'gtk2'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'libs')
+require 'gui/build_list_view_entry'
+require 'gui/builder_list_view'
+require 'gui/build_details_pane'
+require 'gui/builder_monitor_window'

data/rbuilder/gui/build_details_pane.rb

@@ -0,0 +1,105 @@
+require 'gui/images'
+module Gui
+    class LogWidget 
+        attr_reader :gtk_container
+        def initialize(build_report)
+            @gtk_container = Gtk::Frame.new "Build log" 
+            gtk_container.shadow_type = Gtk::SHADOW_IN
+            
+            gtk_container << window = Gtk::ScrolledWindow.new
+            window << @text_view = Gtk::TextView.new
+            text_view.editable = false
+            @build_report = build_report
+            build_report.add_observer(self)
+        end
+        
+        def attach_to(new_build_report)
+            build_report.delete_observer(self)
+            @build_report = new_build_report
+            build_report.add_observer(self)
+            update
+        end
+        
+        def update(options = {})
+            update_text(options[:log_line]) and return if options.has_key?(:log_line)
+            set_text(build_report.log)
+        end
+        
+        def update_text(line)
+            text_view.buffer.insert(text_view.buffer.end_iter, line + $/)
+        end
+        
+        def set_text(new_text)
+            text_view.buffer.text=new_text
+        end
+        
+        def text
+            text_view.buffer.text
+        end
+        
+        private 
+        attr_reader :build_report, :text_view
+    end
+    
+    class StatusWidget 
+        Image = {BuildStatus.ok => Images.file('ok.gif'), BuildStatus.failed => Images.file('failed.gif'), BuildStatus.building => Images.file('building.gif')}
+        Image.default = ''
+        attr_reader :gtk_container
+        
+        def initialize(build_status)
+            @gtk_container = Gtk::Image.new(Image[build_status])
+        end
+        
+        def status=(new_status)
+            @gtk_container.file=Image[new_status]
+            
+        end
+    end
+    
+    class BuildDetailsPane
+        attr_reader :build, :gtk_container
+        attr_reader :archive_label, :reason_label
+        def initialize(build, status_widget = nil, log_widget = nil)
+            @status_widget = status_widget || StatusWidget.new(build.status)
+            @log_widget = log_widget || LogWidget.new(build.report)
+            @archive_label = Gtk::Label.new
+            @reason_label = Gtk::Label.new
+            
+            @gtk_container = Gtk::VBox.new
+            add_label("builing archive:", archive_label)
+            add_label("    with reason:", reason_label)
+            @gtk_container.pack_start(@status_widget.gtk_container, false, false, 5)
+            @gtk_container.pack_start(@log_widget.gtk_container, true, true, 5)
+            
+            attach_to(build)
+            
+        end     
+        
+        def add_label(label_text, widget)
+            box = Gtk::HBox.new
+            label = Gtk::Label.new(label_text)
+            box.pack_start(label, false, false, 10)
+            box.pack_start(widget, false, false, 5)
+            gtk_container.pack_start(box, false, false, 5)
+        end
+        
+        def attach_to(new_build)
+            if (build)
+                build.delete_observer(self)
+            end
+            @build = new_build
+            build.add_observer(self)
+            log_widget.attach_to(build.report)
+            archive_label.text = build.archive
+            reason_label.text = build.reason.to_s
+            update
+        end
+        
+        def update
+            status_widget.status = build.status 
+        end
+        
+        private 
+        attr_reader :status_widget, :reason_widget, :log_widget
+    end
+end