rbuilder 0.0.1

data/rbuilder/gui/build_list_view_entry.rb

@@ -0,0 +1,33 @@
+module Gui
+    class BuildListViewEntry
+        attr_reader :iterator, :build
+        def self.create(build, iterator)
+            entry = BuildListViewEntry.new(build)
+            entry.attach_to(iterator)
+            return entry
+        end
+        def initialize(build)
+            @build = build
+            build.add_observer(self)
+        end
+        
+        def attach_to(iterator)
+            @iterator = iterator
+            update
+        end
+        
+        def update
+            iterator[0] = self
+            iterator[1] = build.archive
+            iterator[2] = build.revision.to_s
+            iterator[3] = build.committer.to_s
+            iterator[4] = build.status.to_s
+            iterator[5] = build.summary.to_s
+        end
+        Colors = {BuildStatus.ok => 'green', BuildStatus.failed => 'red', BuildStatus.building => 'yellow'}
+        def update_renderer_style(renderer)
+            color = Colors[build.status]
+            renderer.background=color if color
+        end
+    end
+end

data/rbuilder/gui/builder_list_view.rb

@@ -0,0 +1,92 @@
+module Gui
+    class BuilderListView
+        attr_reader :gtk_container,:tree_store, :tree_view
+        attr_accessor :monitor_window
+
+        def initialize(builder)
+            initialize_ui_elements
+            builder.each_description {|build_description|  create_build_description_list_view(build_description)}
+        end
+
+        def initialize_ui_elements
+            @tree_store = Gtk::TreeStore.new(BuildListViewEntry,String,String,String,String,String)
+            @tree_view = Gtk::TreeView.new(tree_store)
+            @gtk_container = Gtk::ScrolledWindow.new 
+            gtk_container << tree_view
+            
+            renderer = Gtk::CellRendererText.new
+            %w{Archive Revision Committer Status Summary}.each_with_index do |column, index|
+                col = Gtk::TreeViewColumn.new(column, renderer, :text => index+1)
+                col.resizable=true
+                col.set_cell_data_func(renderer) do |col, renderer, model, iter| 
+                    iter[0].update_renderer_style(renderer)
+                end
+                
+                tree_view.append_column(col)
+            end
+            tree_view.selection.set_select_function do  |selection, model, path, currently_selected|
+	           self.select_build(self.build_for_iterator(model.get_iter(path)))
+	           true
+            end
+        end    
+                
+        def create_build_description_list_view(build_description)
+            BuildDescriptionListView.new(build_description, self, tree_store)
+        end
+        
+        def select_build(build)
+            @selected_build = build
+            monitor_window.build_selected(build)
+        end
+        
+        def replace_build_selection(new_selected_build, build_selection_to_replace)
+            select_build(new_selected_build) if build_selection_to_replace == selected_build || selected_build == nil
+        end
+        
+        def build_for_iterator(iterator)
+            iterator[0].build
+        end
+        
+        private
+        attr_reader :selected_build
+    end
+    
+    class BuildDescriptionListView
+        attr_reader :tree_store, :current_build_view_entry, :build_description, :builder_list_view
+        def initialize(builder, builder_list_view, tree_store = nil) 
+            @listeners = []
+            @build_description = @builder = builder
+            @builder_list_view = builder_list_view
+            @builder.add_observer(self)
+            @tree_store = tree_store
+        end  
+        
+        def update(options = {})
+            replace_build_selection(options[:new_build])
+            new_build_list_view_entry(options[:new_build])
+        end
+        
+        def replace_build_selection(new_build)
+            return unless builder_list_view
+            builder_list_view.replace_build_selection(new_build, current_build) 
+        end
+        
+        def current_build
+            return current_build_view_entry.build if current_build_view_entry
+        end
+        
+        def new_build_list_view_entry(build)
+            if current_build_view_entry
+                current_build_view_entry
+                new_build_list_entry = BuildListViewEntry.create(build,current_build_view_entry.iterator)
+                current_build_view_entry.attach_to(tree_store.prepend(current_build_view_entry.iterator))
+                @current_build_view_entry = new_build_list_entry
+            else
+                @current_build_view_entry = BuildListViewEntry.create(build,tree_store.append(nil))
+            end
+            current_build_view_entry
+        end
+        
+    end
+    
+end

data/rbuilder/gui/builder_monitor_window.rb

@@ -0,0 +1,112 @@
+require 'gui/images'
+module Gui
+    class BuilderMonitorWindow
+        
+        class StatusIcon
+            attr_reader :status
+            def initialize(menu)
+                @icon = Gtk::StatusIcon.new
+                
+                @icon.signal_connect('popup_menu', menu) do |widget,button, time| 
+                    if button == 3
+                        menu.popup(nil,nil,button, time)
+                    end
+                end        
+                self.ok
+            end
+            
+            def ok
+                self.status ='ok_builder' 
+            end
+            
+            def broken
+                self.status ='broken_builder'
+            end
+            
+            def status=(new_status)
+                @status = new_status
+                @icon.file=Images.file("#{status}.gif")
+                
+            end
+            
+            def on_activate(&block)
+                @icon.signal_connect('activate',&block)
+            end
+        end        
+        
+        
+        attr_reader :window, :status_icon, :builder
+        
+        def initialize(builder, builder_list_view, build_details_pane)
+            @builder = builder
+            builder.add_observer(self)
+            @build_details_pane = build_details_pane
+            builder_list_view.monitor_window = self
+            initialize_widgets(builder_list_view)
+        end
+        
+        def initialize_widgets(builder_list_view)
+            initialize_status_icon initialize_menu
+            @window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+            panes = Gtk::VPaned.new
+            panes.pack1(builder_list_view.gtk_container,false, false)
+            panes.pack2(build_details_pane.gtk_container,false, false)
+            window.signal_connect("delete_event") { self.hide }
+            window.add(panes)
+            window.title = "rbuilder monitor"
+            window.width_request = 600
+            window.height_request = 500
+            window.icon_list = [Gdk::Pixbuf.new(Images.file('ok_builder.gif'))]
+        end
+        
+        def initialize_menu
+            menu = Gtk::Menu.new
+            menu.append(show = Gtk::MenuItem.new("Show"))
+            menu.append(hide = Gtk::MenuItem.new("Hide"))
+            menu.append(exit = Gtk::MenuItem.new("Exit"))
+            menu.show_all
+            show.signal_connect('activate') {self.show}
+            hide.signal_connect('activate') {self.hide}
+            exit.signal_connect('activate') {Gtk.main_quit}
+            menu
+        end
+        
+        def initialize_status_icon(menu)
+            @status_icon = StatusIcon.new(menu)
+            status_icon.on_activate  do 
+                toggle
+            end
+        end
+        
+        def build_selected(build)
+            @selected_build = build
+            @build_details_pane.attach_to build 
+        end
+        
+        def show
+            window.show_all
+        end
+        
+        def hide
+            window.hide_all
+        end
+        
+        def toggle
+            if window.visible?
+                window.hide_all
+            else
+                window.show_all
+            end
+        end
+        
+        def update
+            if builder.status == BuilderState.ok
+                status_icon.ok
+            else
+                status_icon.broken
+            end
+        end
+        
+        attr_reader :build_details_pane
+    end
+end

data/rbuilder/gui/images.rb

@@ -0,0 +1,5 @@
+module Gui
+    module Images
+        def self.file(image_name); File.expand_path(File.join(File.dirname(__FILE__),'images',image_name)); end
+    end
+end

data/rbuilder/lib/observer.rb

@@ -0,0 +1,7 @@
+require 'observer'
+module Observable
+    def changed!(*args)
+        changed
+        notify_observers(*args)
+    end
+end

data/rbuilder/libs.rb

@@ -0,0 +1,4 @@
+$: << File.expand_path(File.dirname(__FILE__))
+require 'builder'
+require 'build_configuration'
+require 'build'

data/rbuilder/revision_committed.rb

@@ -0,0 +1,21 @@
+
+class RevisionCommitted
+    attr_reader :committer, :revision
+    def initialize(revision, committer)    
+        @revision = revision
+        @committer = committer
+    end
+    
+    def self.from_source_control_status(status)
+        self.new(status.revision, status.committer)
+    end
+    
+    def ==(other)
+        return false unless other.class == self.class 
+        self.revision == other.revision && self.committer == other.committer
+    end
+    
+    def to_s
+        "Revision #{revision} committed by #{committer}"
+    end
+end

data/rbuilder/source_control.rb

@@ -0,0 +1,3 @@
+require 'source_control/status'
+require 'source_control/tracker'
+require 'source_control/svn'

data/rbuilder/source_control/status.rb

@@ -0,0 +1,23 @@
+module SourceControl
+    class Status
+        attr_reader :revision, :committer
+        def initialize(revision, committer)
+            @revision = revision
+            @committer = committer
+        end
+        
+        
+        def ==(other)
+            other.class == self.class && 
+            other.revision == self.revision && 
+            other.committer == self.committer
+        end
+        
+        def to_s
+            "(#{revision},#{committer})"
+        end
+        def inspect
+            "Status#{to_s}"
+        end
+    end
+end

data/rbuilder/source_control/svn.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+module SourceControl
+    def self.svn(working_dir)
+        new(svn_backend(working_dir))
+    end
+    
+    def self.svn_backend(working_dir)
+        Svn.new(working_dir)
+    end
+    
+    
+    class Svn
+        attr_reader :working_dir
+        def initialize(working_dir)
+            @working_dir = working_dir
+            validate_working_dir
+        end
+       
+        def validate_working_dir
+            unless File.directory?(working_dir)
+                raise DirectoryInvalidException.new("directory does not exist please create a valid checkout first")
+            end
+        end
+        
+        def archive
+            return @archive if @archive 
+            @archive = parse_archive(run_info)
+        end
+         
+        def parse_archive(repo_info)
+            repo_info =~ /^(Repository Root: )(.*)$/
+            line = $2
+            line = strip_server(line)
+            return strip_trunk(line)            
+        end
+        
+        def get_info
+            info_output = run_info
+            revision = info_output[/^Revision:(.*)$/].split(':')[1]
+            committer = info_output[/^Last Changed Author:(.*)$/].split(':')[1].strip
+            Status.new(revision.to_i, committer)
+        end
+        
+        def strip_server(line)
+            return line unless line =~ /(svn.*:\/\/[^\/]*\/)(.*)/ 
+            return $2
+        end
+        
+        def strip_trunk(line)
+            return line unless line =~ /(.*)(\/trunk)/
+            return $1
+        end
+        
+        protected
+        def run_info
+            FileUtils.cd @working_dir do 
+                `svn up`
+                return `svn info`
+            end
+        end
+        
+        
+    end
+end

data/rbuilder/source_control/tracker.rb

@@ -0,0 +1,36 @@
+ module SourceControl
+     class DirectoryInvalidException < Exception; end
+    
+     class Tracker
+         attr_reader :backend
+         
+         def initialize(backend)
+             @backend = backend
+             @current_revision = nil
+         end
+         
+         def report_change_to(builder)
+             source_control_info = backend.get_info
+             if source_control_info.revision != current_revision 
+                 builder.new_revision_committed(source_control_info) 
+                 @current_revision = source_control_info.revision
+             end
+         end
+         
+         def working_dir
+            backend.working_dir
+         end
+         
+         def archive 
+            backend.archive
+         end
+         
+         private
+         attr_reader :current_revision
+     end
+     
+     def self.new(source_control_backend)
+         Tracker.new(source_control_backend)
+     end
+     
+ end

data/tests/gui/test_build_details_pane.rb

@@ -0,0 +1,118 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+require File.join(File.dirname(__FILE__), '..', 'builder_test_env')
+require 'rbuilder/gui'
+
+module Gui
+    class TestBuildDetailsPane < Test::Unit::TestCase
+        attr_reader :pane, :build, :build_report, :status_widget, :log_widget
+        
+        def setup
+            @build_report = stub('initial_build_report', :delete_observer => nil, :add_observer => nil, :log => '')
+            @build = stub_everything('initial_build')
+            build.stubs(:report).returns(build_report)
+            build.stubs(:archive).returns "the_archive"
+            build.stubs(:status).returns BuildStatus.ok
+            build.stubs(:reason).returns "some_reason"
+            @status_widget = stub('status_widget', :gtk_container => Gtk::Label.new, :status= => nil)
+            @log_widget = stub('log_widget', :attach_to => nil, :gtk_container => Gtk::Label.new)
+            @pane = BuildDetailsPane.new(build, status_widget, log_widget)
+        end
+
+        def test_contains_label_with_archive_name
+            assert_equal 'the_archive', pane.archive_label.text 
+        end
+        
+        def test_contains_label_with_reason
+            assert_equal 'some_reason', pane.reason_label.text 
+        end
+                
+        def test_observes_build_upon_creation
+            build.expects(:add_observer).with(instance_of(BuildDetailsPane))
+            pane = BuildDetailsPane.new(build)
+        end
+        
+        def test_observes_build_report_and_build_upon_attach_to
+            build.expects(:delete_observer).with(pane)
+            other_build_report = mock('other_build_report')
+            other_build = stub('other_build', :report => other_build_report, :archive => 'other_archive', :reason => 'some_other_reason')
+            
+            other_build.expects(:add_observer).with(pane)
+            log_widget.expects(:attach_to).with(other_build_report)
+            pane.expects :update
+            pane.attach_to(other_build)
+            assert_equal 'other_archive', pane.archive_label.text 
+            assert_equal 'some_other_reason', pane.reason_label.text 
+        end
+        
+        
+        def test_update_pushes_status_information_to_attached_widgets
+            status_widget.expects(:status=).with(BuildStatus.ok)
+            pane.update
+        end
+        
+    end
+    
+    class TestStatusWidget < Test::Unit::TestCase
+        attr_reader :widget
+        def setup
+            @widget = StatusWidget.new(BuildStatus.ok)
+        end
+        
+        def test_sets_status_in_image
+            assert_equal Gtk::Image, widget.gtk_container.class
+            assert_equal "ok.gif", File.basename(widget.gtk_container.file)
+        end
+        
+        def test_changing_status_changes_the_file_not_the_label
+            expected_gtk_container = widget.gtk_container
+            
+            widget.status = BuildStatus.failed
+            assert_equal "failed.gif", File.basename(widget.gtk_container.file)
+            assert_equal expected_gtk_container, widget.gtk_container
+        end
+    end
+    
+    class TestLogWidget < Test::Unit::TestCase
+        attr_reader :widget, :build_report
+        def setup
+            @build_report = stub_everything
+            @widget = LogWidget.new(build_report)
+        end
+        
+        def test_obseves_build_erport_upon_creation
+            build_report.expects(:add_observer).with(instance_of(LogWidget))
+            widget = LogWidget.new(build_report)
+        end 
+        
+        def test_obseves_build_erport_upon_attach
+            new_build_report = mock
+            build_report.expects(:delete_observer).with(widget)
+            new_build_report.expects(:add_observer).with(widget)
+            widget.expects :update
+            widget.attach_to(new_build_report)
+        end 
+        
+        def test_update_log_line_is_added_to_text
+            new_log_line = "bla di bla"
+            another_log_line = "rob is gek"
+            
+            widget.update(:log_line => new_log_line)
+            assert_match new_log_line, widget.text
+            assert_no_match(/#{another_log_line}/, widget.text)
+
+            widget.update(:log_line => another_log_line)
+            assert_match another_log_line, widget.text
+        end
+        
+        def test_update_sets_complete_text
+            the_log = "some\nlog\nlines"
+            build_report.stubs :log => the_log
+            widget.update
+            assert_equal the_log, widget.text
+        end
+    end
+    
+    
+end