BuildMaster 0.5.0

data/lib/buildmaster/source_file_handler.rb

@@ -0,0 +1,68 @@
+
+
+require 'webrick'
+require 'file_processor'
+
+module BuildMaster
+
+class SourceFileHandler < WEBrick::HTTPServlet::AbstractServlet
+# uncomment the following for automatic servlet reloading
+  def SourceFileHandler.get_instance config, *options
+    load __FILE__
+    SourceFileHandler.new config, *options
+  end
+
+  def initialize(server, spec)
+    super
+    @config = server.config
+    @logger = @config[:Logger]
+    @spec = spec
+    @delegate = WEBrick::HTTPServlet::FileHandler.new(server, spec.content_dir, true)
+  end
+  
+  def service(req, res)
+    path = req.path_info
+    extension = File.extname(path)
+    if (extension == '')
+      path = "#{path}index.html"
+      extension = '.html'
+    end
+    if (extension.casecmp('.html') == 0)
+      begin
+        serve_generated_file(path[0, path.length - 5], req, res)
+      rescue Exception
+        @logger.error("error serving the file #{path}")
+        @logger.error($!)
+        raise WEBrick::HTTPStatus::InternalServerError, 
+          "#{$!}", caller
+      end
+    else
+      @delegate.service(req, res)
+    end
+  end
+  
+  private
+  def serve_generated_file(path, req, res)
+    file_path = @spec.content_dir + path
+    textile_file = "#{file_path}.textile"
+    html_file = "#{file_path}.html"
+    if File.file? textile_file
+      stats = File::stat(textile_file)
+      document = FileProcessor.new(@spec.load_template, textile_file, @spec).process_textile()
+    elsif File.file? html_file
+      stats = File::stat(html_file)
+      document = FileProcessor.new(@spec.load_template, html_file, @spec).process_html()
+    end
+    if (document)
+      content = document.to_s
+      res['content-type'] = 'text/html'
+      res['content-length'] = content.length
+      res['last-modified'] = stats.mtime.httpdate
+      res.body = content
+    else
+      @delegate.service(req, res)
+    end
+  end
+end
+
+end

data/lib/buildmaster/svn_driver.rb

@@ -0,0 +1,68 @@
+require 'rexml/document'
+
+module BuildMaster
+
+class SvnInfo
+    attr_reader :path, :repository_root
+    
+    def initialize(path)
+        @path = path
+        analyze_entry_file(File.join(path, ".svn", "entries"))
+    end
+    
+    def analyze_entry_file(file)
+        xml = REXML::Document.new(File.open(file))
+        xml.root.each_element_with_attribute('name', '', 1) do |element|
+            @repository_root = element.attributes['repos']
+        end
+    end
+end
+
+class SvnDriver
+    include Shell
+    
+    def SvnDriver::from_path(directory)
+        return SvnDriver.new(SvnInfo.new(directory))
+    end
+    
+    def initialize(svn_info, &command_runner)
+        @svn_info = svn_info
+        if (command_runner)
+            @command_runner = command_runner
+        else
+            @command_runner = Proc.new {|command| run(command)}
+        end
+    end
+    
+    def status
+        command_for_path('status')
+    end
+    
+    def update
+        command_for_path('update')
+    end
+    
+    def commit(comment)
+        command_for_path('commit', " -m \"#{comment}\"") 
+    end
+    
+    def tag(tag_name)
+        run_command("svn copy #{@svn_info.repository_root}/trunk #{@svn_info.repository_root}/tags/#{tag_name} -m \"ruby buildmaster\"")
+    end
+    
+    def checkout(output)
+        run_command("svn checkout #{@svn_info.repository_root}/trunk #{output}")
+    end
+    
+    def command(command)
+        command_for_path(command)
+    end
+    
+    private
+    
+    def command_for_path(svn_command, argument='')
+        run_command("svn #{svn_command} #{@svn_info.path}#{argument}")
+    end
+end
+
+end

data/lib/buildmaster/template_runner.rb

@@ -0,0 +1,128 @@
+module BuildMaster
+  class TemplateRunner
+    NAMESPACE = "http://buildmaster.rubyforge.org/xtemplate/1.0"
+
+    def initialize(result, template, source, &evaluator)
+      @result = result
+      @template = template
+      @source = source
+      @evaluator = evaluator
+    end
+        
+    def process
+      process_children(@result, @template)
+    end
+        
+    private
+    def process_children(target, template)
+      template.each do |element|
+        if (element.kind_of? REXML::Element)
+          process_element(target, element)
+        else
+          target.add(deep_clone(element))
+        end
+      end
+    end
+        
+    def process_element(target, element)
+      if (template_directive?(element))
+        process_directive(target, element)
+      else
+        output_element = clone_element(element)
+        target.add(output_element)
+        process_children(output_element, element)
+      end
+    end
+        
+    def template_directive?(element)
+      element.namespace == NAMESPACE
+    end
+        
+    def process_directive(target, template_element)
+      begin
+        action = method("process_#{template_element.name}_directive")
+        action.call(target, template_element)
+      rescue NameError
+        raise TemplateException,
+          "unable to process template:#{template_element.name}: #{$!}" ,
+          caller
+      end
+    end
+
+    def clone_element( template_element )
+      cloned_element = REXML::Element.new( template_element.expanded_name )
+      copy_attributes( template_element, cloned_element )
+      cloned_element
+    end
+        
+    def copy_attributes( template_element, expanded_element )
+      template_element.attributes.each_attribute do |attribute|
+          expanded_element.attributes.add( attribute.clone )
+      end
+    end
+        
+    def deep_clone( node )
+      if node.kind_of? REXML::Parent
+        node.deep_clone
+      else
+        node.clone
+      end
+    end
+        
+    def process_include_directive(target_element, template_element)
+      elements_attribute = template_element.attributes["elements"]
+      if (elements_attribute)
+        REXML::XPath.match(@source, elements_attribute).each do |matched|
+          target_element.add(deep_clone(matched))
+        end
+        return
+      end
+    end
+        
+    def process_when_directive(target_element, template_element)
+      if evaluate(template_element, 'test')
+        process_children(target_element, template_element)
+      end
+    end
+        
+    def process_attribute_directive(target_element, template_element)
+      name = template_element.attributes['name']
+      target_element.attributes[name]=evaluate(template_element, 'eval')
+    end
+        
+    def process_text_directive(target_element, template_element)
+      target_element.add(REXML::Text.new(evaluate(template_element, 'eval')))
+    end
+        
+    def process_each_directive(target_element, template_element)
+      source_xml = evaluate!(template_element, 'source')
+      matched_element = REXML::XPath.match(REXML::Document.new(source_xml), template_element.attributes['select'])
+      count = attribute!(template_element, 'count')
+      count.to_i.times do |i|
+        TemplateRunner.new(target_element, template_element, matched_element[i], &@evaluator).process
+      end
+    end
+    
+    def evaluate!(xml_element, attribute_name)
+      value = evaluate(xml_element, attribute_name)
+      message = xml_element.attributes[attribute_name]
+      if (not value)
+        raise TemplateException, "#{message} from attribute #{attribute_name} cannot be nil"
+      end
+      return value
+    end
+        
+    def evaluate(xml_element, attribute_name)
+      message = attribute!(xml_element, attribute_name)
+      return @evaluator.call(message)
+    end
+    
+    def attribute!(xml_element, attribute_name)
+      value = xml_element.attributes[attribute_name]
+      if (not value)
+        raise TemplateException, "attribute #{attribute_name} not found in #{xml_element}"
+      end
+      return value
+    end
+  end
+end

data/lib/buildmaster/try.rb

@@ -0,0 +1,3 @@
+# puts global_variables
+puts ENV["path"]
+puts nil.split(' ')

data/lib/buildmaster/xtemplate.rb

@@ -0,0 +1,28 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rexml/document'
+require 'template_runner'
+
+module BuildMaster
+  class TemplateException < Exception
+  end
+    
+  class XTemplate
+    def initialize(template_file)
+      @template = REXML::Document.new(template_file)
+    end
+        
+    def process(content, &evaluator)
+      content_xml = REXML::Document.new(content)
+      output_xml = process_xml(content_xml, &evaluator)
+      return output_xml
+    end
+        
+    private
+    def process_xml(content_xml, &evaluator)
+      result_xml = REXML::Document.new
+      TemplateRunner.new(result_xml, @template, content_xml, &evaluator).process
+      return result_xml
+    end
+  end
+end

data/lib/mock.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'mock/mock_base.rb'

data/lib/mock/mock_base.rb

@@ -0,0 +1,24 @@
+require 'set'
+require 'test/unit'
+
+class Mock
+  def initialize(class_to_mock=nil)
+    @class_to_mock = class_to_mock
+    @expectations = Set.new
+  end
+  
+  def expects(message)
+    @expectations.add(message)
+  end
+  
+  def verify
+    
+  end
+  
+  def method_missing(method, *args)
+    if (not @expectations.include? method)
+      raise "Unexpected extra call to #{method}"
+    end
+  end
+  
+end

data/test/buildmaster/build.xml

@@ -0,0 +1,8 @@
+<project name="ant-test">
+  <target name="passing" description="A target that passes">
+    <echo message="invoked"/>
+  </target>
+  <target name="failing" description="A target that fails">
+    <fail message="failure message"/>
+  </target>
+</project>

data/test/buildmaster/content/index.html

@@ -0,0 +1,7 @@
+<!DOCTYPE html
+    PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">    
+    <body><h1>Text</h1>
+  </body>
+</html>

data/test/buildmaster/tc_ant_client.rb

@@ -0,0 +1,27 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
+
+require 'test/unit'
+require 'buildmaster'
+
+class AntTest < Test::Unit::TestCase
+  protected
+  def setup
+    super
+    build_file = File.join(File.dirname(__FILE__), "build.xml")
+    @ant = Ant.new(build_file)
+  end
+
+  public
+  
+  def test_run
+    @ant.project_help
+  end
+  
+  def test_pass
+    @ant.target('passing')
+  end
+  
+  def test_fail
+    assert_raise(RuntimeError) {@ant.target('failing')}
+  end
+end

data/test/buildmaster/tc_cvs_client.rb

@@ -0,0 +1,62 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
+
+require 'test/unit'
+require 'buildmaster'
+
+class CvsClientTest < Test::Unit::TestCase
+  protected
+  def setUp() 
+    super
+  end
+  
+  private 
+  def ensure_folder_exists(path)
+    if (not File.exists? path)
+      Dir.mkdir(path)      
+    end
+  end
+  
+  public
+  def test_load_CvsInfo
+    folder = 'tmp'
+    ensure_folder_exists(folder);
+    root = ':ext:wolfdancer@cvsserver.com:/cvs/root'
+    repository = 'xpe'
+    write("#{folder}/ROOT", root)
+    write("#{folder}/Repository", repository)
+    cvs = CvsInfo.load(folder)
+    assert_equal(root, cvs.root)
+    assert_equal(repository, cvs.repository)
+  end
+  
+  def tes_checkout
+    log = ''
+    client = CvsClient.new(CvsInfo.new('root', 'module'), 'working') {|command| log = command}
+    client.checkout
+    assert_equal('cvs -d root co -d working module', log)
+  end
+  
+  def test_update
+    log = ''
+    client = CvsClient.new(CvsInfo.new('root', 'module'), 'working') {|command| log = command}
+    client.update
+    assert_equal('cvs -d root update working', log)
+    client.update('-PAd')
+    assert_equal('cvs -d root update -PAd working', log)
+  end
+  
+  def test_command
+    log = ''
+    client = CvsClient.new(CvsInfo.new('root', 'module'), 'working') {|command| log = command}
+    client.command('command -option argument')
+    assert_equal('cvs -d root command -option argument working', log)
+  end
+  
+  private 
+  def write(fileName, content)
+    File.open(fileName, "w") do |file|
+      file.puts content
+    end
+  end
+
+end

data/test/buildmaster/tc_release_control.rb

@@ -0,0 +1,23 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
+
+require 'test/unit'
+require 'buildmaster'
+require 'mock'
+
+class ReleaseTest < Test::Unit::TestCase
+  def testRelease
+    cvs_mock = Mock.new(CvsClient)
+    cvs_mock.expects(:checkout)
+    cvs_mock.expects(:tag)
+    cvs_mock.expects(:commit)
+    
+    builder_mock = Mock.new
+    builder_mock.expects(:build)
+    
+    release = Release.new(cvs_mock, builder_mock)
+    release.release_candidate('tag')
+    
+    cvs_mock.verify
+    builder_mock.verify
+  end
+end