xcb 0.0.1

data/bin/xcb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+gem 'xcb'
+
+
+require 'xcb_command'
+
+config =  StackingConfig.load(".xcb.yaml") <<
+          StackingConfig.load("config/xcb.yaml") <<
+          StackingConfig.load(ENV["HOME"] + "/.xcb.conf") <<
+          StackingConfig.load("/etc/xcb.conf")
+
+xcb = XCB.new(config)
+
+case ARGV.shift
+  when nil, "", "build"
+    status = xcb.build
+    puts status.inspect
+    exit (status == :succesful)
+  when "clean"
+    xcb.clean  
+  when "start"
+    xcb.start_building
+  when "stop"
+    xcb.stop_building
+  when "growltest"
+    ExtremeContinuousBuilder::GrowlNotifier.setup config
+    ExtremeContinuousBuilder::GrowlNotifier.instance.notify :succesful, "Test OK"
+    puts "You should see a notification"
+  
+  else
+    puts "Commands:"
+    puts "\tbuild:\tPerforms one build"
+    puts "\tstart:\tStarts building the the background"
+    puts "\tstop:\tStops building in the background"
+    puts "\tclean:\tClears out PIDs and logs"
+    puts
+    exit 1
+end

data/lib/directory_monitor.rb

@@ -0,0 +1,30 @@
+class DirectoryMonitor
+  def initialize(dir, ops = {})
+    @base_dir = dir
+    @mtimes = nil
+    @ignore = [ops[:ignore]].flatten.compact
+    update! if ops[:update]
+  end
+  
+  def has_changes?
+    old_mtimes = @mtimes
+    @last_result = old_mtimes != update!
+    had_changes?
+  end
+
+  def had_changes?
+    @last_result
+  end
+
+  def update!
+    ignore_list = @ignore.map{|ig| Dir.glob(ig)}.flatten.map{|f|File.expand_path f}
+    files = Dir.glob(File.join(@base_dir, "**/*")).map{|f|File.expand_path f}
+    @mtimes = files.inject({}) do |result, file|
+      if ignore_list.include? file
+        result
+      else
+        result.merge( { file => File.mtime(file) } )
+      end
+    end
+  end  
+end

data/lib/extreme_continuous_builder.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/notifiers'
+require "timeout"
+
+module ExtremeContinuousBuilder
+  class Build
+    attr_reader :output, :success, :status
+
+    def initialize(options = {})
+      @options  = options
+      @log_file_path  = options[:log_file_path]
+      @lock_file_path = options[:lock_file_path]
+      @status   = Status.new(log_file_path)
+    end
+ 
+    # Runs the tests, returns one of the fiollowing:
+    #   ::failed:     The test started failing
+    #   ::broken:     The test is still failing
+    #   ::succesful:  The test is still working
+    #   ::revived:    The test started working, you fixed it
+    def run
+      under_lock do
+        previous_status = @status.recall
+      
+        if status = make
+          @status.keep(:succesful)
+          (previous_status == :succesful or previous_status == false) ? :succesful : :revived
+        else
+          @status.keep(:failed)
+          previous_status == :failed ? :broken : :failed
+        end
+      end
+    end
+    
+    def clean
+      File.delete log_file_path if File.exist? log_file_path
+      File.delete lock_file_path if File.exist? lock_file_path
+    end
+ 
+    private
+      def log_file_path
+        @log_file_path ||= File.join(@options[:application_root], ".last_build.log")
+      end
+    
+      def lock_file_path
+        @lock_file_path ||= File.join(@options[:application_root], '.continuous_builder.pid')
+      end
+    
+      def make
+        @output = `cd #{@options[:application_root]} && #{@options[:bin_path]}rake #{@options[:task_name]} 2>&1`
+        make_successful?
+      end
+      
+      def make_successful?
+        $?.exitstatus == 0
+      end
+      
+      def under_lock
+        wait_for_lock
+
+        begin
+          grab_lock
+          yield
+        ensure
+          release_lock
+        end
+      end
+      
+      def wait_for_lock
+        begin
+          Timeout::timeout(600) do # timeout after 10 minutes
+            while File.exists?(lock_file_path)
+              sleep(2) # check back after 10 seconds
+            end
+          end
+        rescue Timeout::Error
+          exit(1) # abort build
+        end
+      end
+      
+      def grab_lock
+        File.open(lock_file_path, 'w') { |f| f << $$ }
+      end
+      
+      def release_lock
+        File.delete(lock_file_path)
+      end
+  end
+
+  class Status
+    def initialize(path)
+      @path = path
+    end
+    
+    def keep(status)
+      File.open(@path, "w+", 0777) { |file| file.write(status.to_s) }
+    end
+    
+    def recall
+      if File.exists?(@path)
+         value = File.read(@path)
+         value.empty? ? false : value.to_sym
+      else
+         false
+      end
+    end
+  end
+end
+

data/lib/notifiers.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+gem 'ruby-growl'
+require 'ruby-growl'
+require 'singleton'
+
+module ExtremeContinuousBuilder
+  def self.notifiers
+    constants.select{|c|c =~ /.+Notifier$/}.map{|name| const_get(name).instance}
+  end
+  
+  
+  class Notifier
+    include Singleton
+    def setup(settings)
+    end
+    
+    def self.setup(settings)
+      instance.setup(settings) if instance.respond_to? :setup
+    end
+    
+    BUILD_RESULT_TYPES = [:failed, :broken, :succesful, :revived]
+    
+    #declare noop methods
+    BUILD_RESULT_TYPES.each do |name|
+      code = lambda{|build|}        
+      define_method name, code
+    end
+  end
+  
+  class GrowlNotifier < Notifier
+    def setup(settings)
+      @application_name = settings[:application_name]
+      growl_host = settings[:growl_host] || "localhost"
+      growl_password = settings[:growl_password]
+      @has_been_setup = true
+      
+      @growl_notifier = Growl.new(growl_host, "XCB", 
+                BUILD_RESULT_TYPES.map{|sym| sym.to_s}, nil, growl_password)
+      nil
+    end
+  
+    BUILD_RESULT_TYPES.each do |name|
+      code = lambda do |build|
+        notify name, build.output
+      end
+      define_method name, code
+    end
+    
+    def notify(type, text)
+      notifier.notify type.to_s, format_title(type), build_summary(text)
+    end
+  
+    private
+    LINE_TO_LOOK_FOR = /[0-9]+ tests, [0-9]+ assertions, [0-9]+ failures, [0-9]+ errors/
+    def build_summary(text)
+      text.split("\n").select{|l| l =~ LINE_TO_LOOK_FOR }.join("\n")
+    end
+  
+    def format_title(type)
+      "[#{@application_name}] Build #{type.to_s}"
+    end
+    
+    def notifier=(n)
+      @growl_notifier = n
+    end
+    
+    def notifier
+      @growl_notifier
+    end
+  end
+
+  
+  class TextFileNotifier < Notifier
+    def setup(options)
+      @application_name = options[:application_name]
+      @text_file_path = options[:text_file_path]
+      @has_been_setup = true
+    end
+    
+    def failed(build)
+      update_file "[#{@application_name}] Build failed", build.output
+    end
+    
+    def broken(build)
+      update_file "[#{@application_name}] Build still broken", build.output
+    end
+    
+    def revived(build)
+      clear_file
+    end
+        
+    private
+    def file_name
+      @text_file_path
+    end
+
+    def clear_file
+      File.delete(file_name) if File.exists? file_name
+    end
+
+    def update_file(status, text)
+      File.open(file_name, "w", 0777) do |file|
+        file.write(status.to_s)
+        file.write("\n")
+        file.write("="*80)
+        file.write("\n")
+        file.write(text)
+      end
+    end
+  end
+end

data/lib/stacking_config.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+class StackingConfig
+  def initialize(ops = {})
+    @parents = []
+    @data = {}
+    @location = ops.delete(:location)
+  end
+  
+  def << (other)
+    @parents = [other] + @parents
+    self
+  end
+
+  def [](key)
+    raise ArgumentError, "Expected key to be a symbol, or string" unless key.respond_to? :to_sym
+    @data[key.to_sym] || get_first_parent_result(key.to_sym)
+  end
+
+  def []=(key, value)
+    raise ArgumentError, "Expected key to be a symbol, or string" unless key.respond_to? :to_sym
+    @data[key.to_sym] = value
+  end
+  
+  def self.load(file)
+    config = new(:location => file)
+    if File.exist? file
+      data = YAML.load_file(file)
+      data.each {|k,v| config[k] = v }
+    end
+    config
+  end
+  
+  def get_first_parent_result(k)
+    @parents.each do |p|
+      return p[k] if p[k]
+    end
+    nil
+  end
+end

data/lib/xcb_command.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/extreme_continuous_builder'
+require File.dirname(__FILE__) + '/stacking_config'
+require File.dirname(__FILE__) + '/directory_monitor'
+
+class XCB
+  def initialize(config)
+    @app_root = config[:app_root] || "."
+    @poller_pid_file = config[:task] || ".xcb_poller.pid"
+    
+    @build = ExtremeContinuousBuilder::Build.new(
+      :task_name        => config[:task] || 'test',
+      :application_root => @app_root
+    )
+
+    @project_name = config[:app_name] ||
+        if File.basename(Dir.pwd) == "trunk"
+          File.basename(File.dirname(Dir.pwd))
+        else
+          File.basename(Dir.pwd)
+        end
+    
+    @text_output_path = config[:text_file_path] || "build_result.txt"
+    
+    notifier_options = {
+      :application_name         => @project_name,
+      :growl_host               => config[:growl_host] || "localhost",
+      :growl_password           => config[:growl_password],
+      :text_file_path           => @text_output_path,
+    }
+    
+    ExtremeContinuousBuilder.notifiers.each do |notifier| 
+      notifier.setup(notifier_options)
+    end
+  end
+  
+  def start_building
+    @monitor = DirectoryMonitor.new(@app_root, :ignore => @text_output_path)
+
+    daemonize!
+
+    File.open(@poller_pid_file, "w") {|f| f.write Process.pid }
+
+    while pid_file_is_me?
+      if @monitor.has_changes?
+        build 
+        sleep 10
+      else
+        sleep 1
+      end
+    end
+  end
+    
+  def stop_building
+    if read_pid_file.nil?
+      :not_running
+    else
+      pid = read_pid_file
+      Process.kill("TERM", pid) if pid
+      delete_pid_file
+      :stopped
+    end
+  end
+  
+  def build
+    status = @build.run
+
+    if [:failed, :revived, :broken, :succesful].include? status
+      ExtremeContinuousBuilder.notifiers.each do |notifier| 
+        notifier.send(status, @build) if notifier.respond_to? status
+      end
+      status
+    else
+      raise "Unexpected build result: #{status.inspect}"
+    end    
+  end
+
+  def clean
+    @build.clean
+  end
+  
+  
+  protected
+  # Checks that the PID file that eas created still represents this proccess
+  def pid_file_is_me?
+    read_pid_file == Process.pid
+  end
+  
+  def write_pid_file!
+    File.open(@poller_pid_file, "w") {|f| f.write Process.pid }
+  end
+  
+  def read_pid_file
+    File.read(@poller_pid_file).to_i if File.exist? @poller_pid_file
+  end
+  
+  def delete_pid_file
+    File.delete @poller_pid_file if File.exist? @poller_pid_file
+  end
+  
+  def daemonize!
+    exit!(0) if fork
+    Process::setsid
+    exit!(0) if fork
+    STDIN.reopen("/dev/null")
+    STDERR.reopen("/dev/null", "w")
+    STDOUT.reopen("/dev/null", "w")
+    yield if block_given?
+  end
+end

data/test/builder_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class BuilderTest < Test::Unit::TestCase
+  def test_ok_with_clean
+    clean_logs
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=6"}))
+    assert_equal(:succesful, builder.run) 
+    assert_equal(:succesful, status.recall)
+  end
+
+  def test_ok_with_succesful
+    clean_logs
+    set_last_result(:succesful)
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=6"}))
+    assert_equal(:succesful, builder.run) 
+    assert_equal(:succesful, status.recall)
+  end
+
+  def test_ok_with_failed
+    clean_logs
+    set_last_result(:failed)
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=6"}))
+    assert_equal(:revived, builder.run) 
+    assert_equal(:succesful, status.recall)
+  end
+  
+  
+  def test_locking
+    build = ExtremeContinuousBuilder::Build.new XCB_OPS
+    build.send :grab_lock
+    Thread.new(build) {|b| sleep 1; b.send :release_lock}
+    started_time = Time.now
+    build.send :wait_for_lock
+    assert((Time.now - started_time).to_i > 1, "It all happened too fast")
+    assert((Time.now - started_time).to_i < 3, "It all happened too slow")
+  end
+  
+  def test_bad_with_clean
+    clean_logs
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:failed, builder.run) 
+    assert_equal(:failed, status.recall)
+  end
+
+  def test_bad_with_succesful
+    clean_logs
+    set_last_result(:succesful)
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:failed, builder.run) 
+    assert_equal(:failed, status.recall)
+  end
+
+  def test_bad_with_failed
+    clean_logs
+    set_last_result(:failed)
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:broken, builder.run) 
+    assert_equal(:failed, status.recall)
+  end
+end

data/test/directory_monitor_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/test_helper'
+class DirectoryMonitorTest < Test::Unit::TestCase
+  BASE_TEST_DIR = "/tmp/DirectoryMonitorTest"
+  TEST_DIRS = ["#{BASE_TEST_DIR}/dir1", "#{BASE_TEST_DIR}/dir2", "#{BASE_TEST_DIR}/dir1/dir3", "#{BASE_TEST_DIR}/dir1/dir4"]
+  DIRS_TO_KILL = TEST_DIRS.reverse + [BASE_TEST_DIR]
+
+  def setup
+    teardown if File.exist? BASE_TEST_DIR
+    Dir.mkdir BASE_TEST_DIR
+    TEST_DIRS.each do |d|
+      Dir.mkdir d
+    end
+  end
+  
+  def teardown
+    DIRS_TO_KILL.each do |d|
+      Dir.glob(d + "/*.tmp", File::FNM_DOTMATCH).each do |file|
+        File.delete file if File.file? file
+      end
+      Dir.delete d if File.exist? d
+    end
+  end
+  
+  def test_initial_usage
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR)
+    assert_equal(nil, monitor.had_changes?)
+    assert_equal(true, monitor.has_changes?)
+    assert_equal(true, monitor.had_changes?)
+    assert_equal(false, monitor.has_changes?)
+    assert_equal(false, monitor.had_changes?)
+    assert_equal(false, monitor.has_changes?)
+  end
+  
+  def test_initial_usage_with_update
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true)
+    assert_equal(nil, monitor.had_changes?)
+    assert_equal(false, monitor.has_changes?)
+    assert_equal(false, monitor.had_changes?)
+
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true)
+    assert_equal(nil, monitor.had_changes?)
+    assert_equal(false, monitor.has_changes?)
+    assert_equal(false, monitor.had_changes?)
+  end
+  
+  def test_simple_change
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true)    
+    assert_equal(false, monitor.has_changes?)
+    assert_equal(false, monitor.has_changes?)
+
+    touch BASE_TEST_DIR, "test_file_one.tmp"
+    assert_equal(true, monitor.has_changes?)
+    assert_equal(false, monitor.has_changes?)
+  end
+
+  def test_ignore_dotfiles
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true)    
+
+    touch BASE_TEST_DIR, ".test_file_one.tmp"
+    
+    assert_equal(false, monitor.has_changes?)
+    assert_equal(false, monitor.has_changes?)
+  end
+
+
+  def test_ignore_ignore_files
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true, 
+          :ignore => File.join(BASE_TEST_DIR, "test_file_ignore.tmp"))
+
+    touch BASE_TEST_DIR, "test_file_ignore.tmp"
+    assert_equal(false, monitor.has_changes?)
+    touch BASE_TEST_DIR, "test_file_one.tmp"
+    assert_equal(true, monitor.has_changes?)
+    
+    sleep 1 # Must sleep between changes, otherwise the files mtimes will be 
+            # the same despite being touched again.
+    monitor = DirectoryMonitor.new(BASE_TEST_DIR, :update => true, 
+          :ignore => [File.join(BASE_TEST_DIR, "test_file_ignore.tmp")])
+
+    touch BASE_TEST_DIR, "test_file_ignore.tmp"
+    assert_equal(false, monitor.has_changes?)
+    touch BASE_TEST_DIR, "test_file_one.tmp"
+    assert_equal(true, monitor.has_changes?)
+  end
+  
+  def touch(*file_name_parts)
+    file_name = File.join(file_name_parts)
+    File.open(file_name, "w+") {|f| f.write ""}
+  end
+end

data/test/exec_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+
+class ExecTest < Test::Unit::TestCase  
+  def test_syntax
+    assert true
+  end
+end

data/test/growl_notifier_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class GrowlNotifierTest < Test::Unit::TestCase
+  include ExtremeContinuousBuilder 
+  def test_growl_notifier_revived
+    clean_logs
+    builder = Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=6"}))
+    assert_equal(:succesful, builder.run)
+    
+    GrowlNotifier.instance.send :notifier=, nil
+    GrowlNotifier.setup(XCB_OPS)    
+    
+    GrowlNotifier.instance.revived builder
+        
+    my_growler = GrowlNotifier.instance.send(:notifier)
+
+    assert_equal(1, my_growler.notifys.size)
+    assert_equal({
+      :type => "revived",
+      :title => "[fake_project] Build revived",
+      :text => "6 tests, 6 assertions, 0 failures, 0 errors",  
+    }, my_growler.notifys[0])
+  end
+  
+  
+  def test_growl_notifier_broken
+    clean_logs
+    builder = Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:failed, builder.run)
+    
+    GrowlNotifier.instance.send :notifier=, nil
+    GrowlNotifier.setup(XCB_OPS)    
+    GrowlNotifier.instance.failed builder
+    my_growler = GrowlNotifier.instance.send(:notifier)
+
+    assert_equal(1, my_growler.notifys.size)
+    assert_equal({
+      :type => "failed",
+      :title => "[fake_project] Build failed",
+      :text => "6 tests, 6 assertions, 3 failures, 0 errors",  
+    }, my_growler.notifys[0])
+  end
+  
+#  def test_flunk
+#    flunk
+#  end
+end

data/test/notifiers_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class NotifiersTest < Test::Unit::TestCase
+  include ExtremeContinuousBuilder
+  NOTIFIERS = [GrowlNotifier.instance, TextFileNotifier.instance]
+  def test_notifiers_list
+    assert_equal(NOTIFIERS, ExtremeContinuousBuilder.notifiers.sort_by{|m| m.to_s})
+  end
+end

data/test/stacking_config_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class StackingConfigTest < Test::Unit::TestCase
+  def setup
+    @one = StackingConfig.load(File.dirname(__FILE__) + "/fixtures/stacking_config/one.yaml")
+    @two = StackingConfig.load(File.dirname(__FILE__) + "/fixtures/stacking_config/two.yaml")
+    @three = StackingConfig.load(File.dirname(__FILE__) + "/fixtures/stacking_config/three.yaml")
+  end
+  
+  
+  def test_basic_loding
+    assert_equal(1, @one[:one_only])
+    assert_equal(1, @two[:two_only])
+
+    assert_nil(@two[:one_only])
+    assert_nil(@one[:two_only])
+  end
+  
+  def test_simple_stack
+    stack = StackingConfig.new() << @one << @two
+    assert_equal(1, stack[:one_only])
+    assert_equal(1, stack[:two_only])
+    assert_equal(3, stack[:two_overides_to_3])
+    
+    assert_equal(1, @one[:one_only])
+    assert_equal(nil, @one[:two_only])
+    assert_equal(2, @one[:two_overides_to_3])
+    
+    assert_equal(nil, @two[:one_only])
+    assert_equal(1, @two[:two_only])
+    assert_equal(3, @two[:two_overides_to_3])
+  end
+
+  def test_larger_stack
+    stack = StackingConfig.new() << @one << @two << @three
+    assert_equal(1, stack[:one_only])
+    assert_equal(1, stack[:two_only])
+    assert_equal(1, stack[:three_only])
+    assert_equal(3, stack[:three_overides_to_3])
+    
+    assert_equal(1, @one[:one_only])
+    assert_equal(nil, @one[:two_only])
+    
+    assert_equal(nil, @two[:one_only])
+    assert_equal(1, @two[:two_only])
+  end
+end

data/test/text_notifier_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class TestNotifierTest < Test::Unit::TestCase  
+  include ExtremeContinuousBuilder
+  def test_text_notifier_failed
+    clean_logs
+    builder = ExtremeContinuousBuilder::Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:failed, builder.run)
+    path = XCB_OPS[:text_file_path]
+    
+    TextFileNotifier.setup XCB_OPS
+    TextFileNotifier.instance.failed builder
+    
+    assert(File.exist?(path), "File should exist.")
+    assert_equal("[fake_project] Build failed\n" + ("="*80) + "\n" + builder.output, File.read(path))
+  end
+  
+  def test_text_notifier_broken
+    clean_logs
+    builder = Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=3"}))
+    assert_equal(:failed, builder.run)
+    path = XCB_OPS[:text_file_path]
+    
+    TextFileNotifier.setup XCB_OPS
+    TextFileNotifier.instance.broken builder
+    
+    assert(File.exist?(path), "File should exist.")
+    assert_equal("[fake_project] Build still broken\n" + ("="*80) + "\n" + builder.output, File.read(path))
+  end
+
+  def test_text_notifier_revived
+    clean_logs
+    builder = Build.new(XCB_OPS.merge({:task_name => "test PASS_COUNT=6"}))
+    assert_equal(:succesful, builder.run)
+    path = XCB_OPS[:text_file_path]
+
+    File.open(path, "w") {|f| f.write "Hello World"}
+    TextFileNotifier.setup XCB_OPS
+    TextFileNotifier.instance.revived builder
+    assert(!File.exist?(path), "File should exist.")
+  end
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: xcb
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tom Lea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-01 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-growl
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: XCB provides the xcb command to continuously build a project in the background.
+email: xcb@clockworkninja.co.uk
+executables: 
+- xcb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/xcb
+- lib/directory_monitor.rb
+- lib/extreme_continuous_builder.rb
+- lib/notifiers.rb
+- lib/stacking_config.rb
+- lib/xcb_command.rb
+has_rdoc: true
+homepage: http://clockworkninja.co.uk/
+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: 
+- Growl with network access enabled
+rubyforge_project: xconbuild
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: XCB provides the xcb command to continuously build a project in the background.
+test_files: 
+- test/builder_test.rb
+- test/directory_monitor_test.rb
+- test/exec_test.rb
+- test/growl_notifier_test.rb
+- test/notifiers_test.rb
+- test/stacking_config_test.rb
+- test/text_notifier_test.rb