BuildMaster 1.1.9 → 1.1.12

data/lib/buildmaster/algorithms.rb

@@ -1,3 +1,3 @@
-$:.unshift File.join(File.dirname(__FILE__), 'algorithms')
+dir = File.dirname(__FILE__)
 
-require 'opn_compare'
+require dir + '/algorithms/opn_compare'

data/lib/buildmaster/auto.rb

@@ -0,0 +1,27 @@
+dir = File.dirname(__FILE__)
+require dir + '/cotta'
+
+project = dir + '/project'
+require project + '/build_number_file'
+require project + '/java_manifest'
+require project + '/ant_driver'
+require project + '/cvs_driver'
+require project + '/pscp_driver'
+require project + '/svn_admin_driver'
+require project + '/svn_driver'
+require project + '/svn_status_info'
+require project + '/server_manager'
+require project + '/version_number_file'
+require project + '/release'
+require project + '/ci'
+
+auto = dir + '/auto'
+require auto + '/classpath'
+require auto + '/git'
+require auto + '/java'
+require auto + '/javac_ant'
+require auto + '/junit_ant'
+require auto + '/package_ant'
+require auto + '/java_project'
+require auto + '/mysql_server'
+require auto + '/ruby_platform'

data/lib/buildmaster/auto/classpath.rb

@@ -0,0 +1,86 @@
+module BuildMaster
+  class ClasspathEntry
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+    end
+
+    def to_ant
+      "    <pathelement location=\"#{@path}\"/>\n"
+    end
+
+    def ==(other)
+      other.class == ClasspathEntry and other.path == path
+    end
+  end
+
+  class ClasspathEntries
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def to_ant
+      return <<RESULT
+    <fileset dir="#{@dir}">
+      <include name="**/*.jar"/>
+    </fileset>
+RESULT
+    end
+  end
+
+  class Classpath
+    
+    def initialize(root = nil)
+      @entries = Array.new
+      @root = root
+    end
+
+    def include?(entry)
+      @entries.include?(convert(entry))
+    end
+
+    def insert(entry)
+      @entries.unshift(convert(entry))
+    end
+
+    def add(entry)
+      @entries.push(convert(entry))
+    end
+
+    def add_all(dir)
+      @entries.push(ClasspathEntries.new(dir))
+    end
+
+    def empty?
+      @entries.empty?
+    end
+
+    def to_ant(id=nil)
+      return '' if empty?
+      result = entries_to_ant
+      if (not id.nil?)
+        result = <<RESULT
+  <path id="#{id}">
+#{result}  </path>
+RESULT
+      end
+      result
+    end
+
+    private
+    def entries_to_ant
+      io = StringIO.new
+      @entries.each {|entry| io << "#{entry.to_ant}"}
+      io.string
+    end
+
+    def convert(entry)
+      if (entry.respond_to? :to_ant)
+        entry
+      else
+        ClasspathEntry.new(entry)
+      end
+    end
+  end
+end

data/lib/buildmaster/auto/git.rb

@@ -0,0 +1,38 @@
+module BuildMaster
+  class Git
+    attr_reader :work_dir
+    def initialize(work_dir)
+      @work_dir = work_dir
+    end
+    
+    def status
+      command('status')
+    end
+    
+    def pull
+      command('pull')
+    end
+    
+    def add(entry=nil)
+      path = '.'
+      path = entry.to_s if entry
+      command("add #{path}")
+    end
+    
+    def commit(comment)
+      comment = comment.sub(/"/, '\""')
+      command("commit -m \"#{comment}\"")
+    end
+    
+    def tag(name)
+      command("tag #{name}")
+    end
+    
+    private
+    def command(command)
+      @work_dir.chdir do
+        @work_dir.cotta.shell("git #{command}")
+      end
+    end
+  end
+end

data/lib/buildmaster/auto/java.rb

@@ -0,0 +1,23 @@
+module BuildMaster
+  class Java
+    def initialize(java_home=nil)
+      @home = java_home
+      if @home.nil?
+        @cotta = Cotta.new
+      else
+        @cotta = @home.cotta
+      end
+    end
+
+    def version
+      @cotta.shell("#{java_exe} -version")
+    end
+
+    private
+    def java_exe
+      exe = 'java'
+      exe = @home.file('bin/java') if @home
+      exe
+    end
+  end
+end

data/lib/buildmaster/auto/java_project.rb

@@ -0,0 +1,185 @@
+module BuildMaster
+  # Java project that knows how to compile the production and test source
+  class JavaProject
+    attr_accessor :output, :name, :target_version
+    attr_reader :root, :prod, :test, :output
+    
+    def initialize(root)
+      @root = root
+      @prod = ProjectInfo.new(self)
+      @prod.classpath = Classpath.new(root)
+      @test = ProjectInfo.new(self)
+      @test.classpath = Classpath.new(root)
+      if block_given?
+        yield self
+      end
+    end
+
+    def src=(dir)
+      prod.src = dir
+    end
+
+    def src
+      prod.src
+    end
+
+    def resource=(dir)
+      prod.resource = dir
+    end
+
+    def resource
+      prod.resource
+    end
+
+    def output=(dir)
+      @output = dir(dir)
+      @prod.output=@output.dir('prod')
+      @test.output=@output.dir('test')
+    end
+
+    # Specifies that the current project uses the entry
+    # The entry can be one of the three things:
+    # It can be another JavaProject, in which case it will be added as a classpath element.
+    # In this case, the project output and its classpath will be part of the current project
+    # classpath.  It can also be a CottaDirectory or CottaFile, in which case it will be added
+    # to the classpath.  It can also be a path string, in which case it will be converted to
+    # CottaFile or CottaDirectory based on whether or not the extname is empty
+    def uses(*entries)
+      add_entry(@prod, entries)
+    end
+
+    def uses_files_in(*dirs)
+      dirs.each {|dir| @prod.classpath.add_all(dir(dir))}
+    end
+
+    def tests_with(*entries)
+      add_entry(@test, entries)
+    end
+
+    def tests_with_files_in(*dirs)
+      dirs.each {|dir| @test.classpath.add_all(dir(dir))}
+    end
+
+    def classpath
+      @prod.classpath
+    end
+
+    def add_project(project)
+      @prod.classpath.add project
+    end
+
+    def javac(buildfile = nil)
+      javac = JavacAnt.new(prod.output, buildfile)
+      javac.target_version = target_version
+      javac.src = prod.src
+      javac.classpath.add prod.classpath unless prod.classpath.empty?
+      javac.resource = prod.resource if prod.resource
+      result = nil
+      if (test.src.nil?)
+        result = [javac]
+      else
+        javac_test = JavacAnt.new(test.output, buildfile)
+        javac_test.target_version = target_version
+        javac_test.src = test.src
+        javac_test.resource = test.resource if test.resource
+        javac_test.classpath.add prod.output
+        javac_test.classpath.add prod.classpath unless prod.classpath.empty?
+        javac_test.classpath.add test.classpath unless test.classpath.empty?
+        result = [javac, javac_test]
+      end
+      result
+    end
+
+    def junit(report_dir)
+      junit = JUnitAnt.new(report_dir, self)
+      junit.classpath.add test.output
+      junit.classpath.add prod.output
+      junit.classpath.add test.classpath
+      junit.classpath.add prod.classpath
+      junit
+    end
+
+    def make(buildfile = nil)
+      javac(buildfile).each {|javac|  javac.compile}
+    end
+
+    def package(dir, name)
+      ant = PackageAnt.new(dir, name)
+      ant.add(prod.output, prod.src)
+      yield ant if block_given?
+      ant.run
+    end
+
+    def jar(file)
+      
+    end
+
+    def clean
+      output.delete
+    end
+
+    def rebuild
+      clean
+      make
+    end
+
+    # create XML classpath element for ANT build file
+    def to_ant
+      io = StringIO.new
+      io << ClasspathEntry.new(prod.output).to_ant
+      io << classpath.to_ant
+      io.string
+    end
+
+    def dir(path)
+      if (path.class == String)
+        @root.dir(path)
+      else
+        path
+      end
+    end
+
+    def file(path)
+      if (path.class == String)
+        @root.file(path)
+      else
+        path
+      end
+    end
+
+    private
+    def guess_entry(entry)
+      path = Pathname.new(entry)
+      if (path.extname.empty?)
+        dir(entry)
+      else
+        file(entry)
+      end
+    end
+
+    def add_entry(target, entries)
+      entries.each do |entry|
+        if (entry.class == String)
+          entry = guess_entry(entry)
+        end
+        target.classpath.add(entry)
+      end
+    end
+  end
+
+  class ProjectInfo
+    attr_accessor :src, :classpath, :output, :resource
+
+    def initialize(project)
+      @project = project
+    end
+
+    def src=(source)
+      @src = @project.dir(source)
+    end
+
+    def resource=(resource)
+      @resource = @project.dir(resource)
+    end
+  end
+end

data/lib/buildmaster/auto/javac_ant.rb

@@ -0,0 +1,64 @@
+module BuildMaster
+  # Javac Ant driver.
+  # This class utilize ANT to perform the javac tasks
+  class JavacAnt
+    attr_reader :output_dir, :classpath
+    attr_accessor :src, :resource, :target_version
+    
+    def initialize(output_dir, buildfile = nil)
+      @output_dir = output_dir
+      @classpath = Classpath.new
+      if (buildfile.nil?)
+        @buildfile = 'buildmaster.xml'
+      else
+        @buildfile = buildfile
+      end
+    end
+
+    def compile()
+      output_dir.mkdirs
+      ant_file = output_dir.parent.file(@buildfile)
+      classpath_ref = 'javac'
+      ant_file.save <<ANT
+<!-- ANT file generated by BuildMaster -->
+<project name="buildmaster">
+#{@classpath.to_ant(classpath_ref)}
+  <target name="javac">
+    <javac srcdir="#{src}" destdir="#{output_dir}" debug="on"#{target_attribute}>
+      #{to_ant_ref(classpath_ref)}
+    </javac>
+    <copy todir="#{output_dir}">
+      #{resource_file_set}
+    </copy>
+  </target>
+</project>
+ANT
+      AntDriver.from_file(ant_file).target("javac")
+    end
+
+    private
+    def to_ant_ref(refid)
+      if (@classpath.empty?)
+        ''
+      else
+        "<classpath refid=\"#{refid}\"/>"
+      end
+    end
+
+    def resource_file_set
+      if (resource.nil?)
+        "<fileset dir=\"#{src}\" excludes=\"**/*.java\"/>"
+      else
+        "<fileset dir=\"#{resource}\"/>"
+      end
+    end
+
+    def target_attribute
+      if target_version.nil?
+        ''
+      else
+        " target=\"#{@target_version}\""
+      end
+    end
+  end
+end

data/lib/buildmaster/auto/junit_ant.rb

@@ -0,0 +1,226 @@
+module BuildMaster
+  # JUnit ANT invocation
+  class JUnitAnt
+    attr_reader :report, :test, :classpath, :jvmargs, :project
+
+    def initialize(report, project = nil)
+      @report = report
+      @classpath = Classpath.new
+      @jvmargs = Array.new
+      @coverage = NilCoverage.new
+      @project = project
+    end
+
+    def target_name
+      'junit-ant'
+    end
+
+    def test_report
+      report.dir('test')
+    end
+
+    def coverage_report
+      report.dir('coverage')
+    end
+
+    def for_test(name)
+      @test = JUnitAntTest.new(self, name)
+      self
+    end
+
+    def for_tests(pattern)
+      @test = JUnitAntBatchTest.new(self, pattern)
+      self
+    end
+
+    def with_coverage(jar)
+      if (jar.basename.include?('cobertura'))
+        @coverage = CobertunaCoverage.new(jar, project)
+      else
+        raise "do not know how to set up coverage tasks for #{jar}"
+      end
+      self
+    end
+
+    def generate(buildfile = nil)
+      if (test.nil?)
+        raise 'test is not specified for junit task'
+      end
+      buildfile = report.file('junit-ant.xml') unless buildfile
+      classpath_id = 'refid'
+      @coverage.modify_classpath(classpath)
+      buildfile.write do |file|
+        file.puts <<BUILD
+<!-- ANT file generated by buildmaste JUnitAnt -->
+<project name="junit-ant" default="junit-ant">
+#{@coverage.task_def}
+#{classpath.to_ant(classpath_id)}
+  <target name="#{target_name}">
+#{@coverage.instrument_task}
+    <junit printsummary="yes" fork="yes" forkmode="perBatch" errorproperty="error" failureproperty="failure" haltonerror="no" haltonfailure="no">
+      <formatter type="xml"/>
+#{@coverage.sysproperty}#{classpath_ref(classpath_id)}#{jvmarg_elements}#{test.to_ant}    </junit>
+    <junitreport todir="#{test_report}">
+        <fileset dir="#{test_report}">
+            <include name="TEST-*.xml"/>
+        </fileset>
+        <report todir="#{test_report}" format="frames"/>
+    </junitreport>
+#{@coverage.report_task(coverage_report)}
+    <fail message="test failed">
+      <condition>
+        <or>
+          <isset property="fail"/>
+          <isset property="error"/>
+        </or>
+      </condition>
+    </fail>
+  </target>
+</project>
+BUILD
+      end
+      buildfile
+    end
+
+    def run(buildfile = nil)
+      buildfile = generate(buildfile)
+      @coverage.clean_instrumented_files
+      test_report.mkdirs
+      coverage_report.mkdirs
+      AntDriver.new(buildfile).target(target_name)
+    end
+
+    private
+
+    def classpath_ref(classpath_id)
+      if (classpath.empty?)
+        ''
+      else
+        "      <classpath refid=\"#{classpath_id}\"/>\n"
+      end
+    end
+
+    def jvmarg_elements
+      if @jvmargs.empty?
+        ''
+      else
+        buffer = StringIO.new
+        @jvmargs.each {|jvm| buffer << "      <jvmarg line=\"#{jvm}\"/>\n"}
+        buffer.string
+      end
+    end
+  end
+
+  class JUnitAntTest
+    attr_reader :name
+    
+    def initialize(junit, name)
+      @name = name
+      @junit = junit
+    end
+
+    def to_ant
+      return <<RESULT
+      <test name="#{name}" todir="#{@junit.test_report}"/>
+RESULT
+    end
+  end
+
+  class JUnitAntBatchTest
+    def initialize(junit, pattern)
+      @junit = junit
+      @pattern = pattern
+    end
+
+    def to_ant
+      return <<RESULT
+      <batchtest fork="yes" todir="#{@junit.test_report}">
+        <fileset dir="#{@junit.project.test.src}">
+          <include name="**/#{@pattern}"/>
+        </fileset>
+      </batchtest>
+RESULT
+    end
+  end
+
+  class NilCoverage
+    def task_def
+      ''
+    end
+
+    def modify_classpath(classpath)
+    end
+
+    def instrument_task
+      ''
+    end
+
+    def sysproperty
+      ''
+    end
+
+    def report_task(report_dir)
+      ''
+    end
+
+    def clean_instrumented_files
+      ''
+    end
+  end
+
+  class CobertunaCoverage
+    def initialize(jar, project)
+      @jar = jar
+      @project = project
+      @instrumented_dir = @project.output.dir('instrumented')
+      @datafile = @project.output.file('cobertuna.ser')
+    end
+
+    def task_def
+      return <<TASK_DEF
+  <path id="coverage">
+    <pathelement location="#{@jar}"/>
+    <fileset dir="#{@jar.parent.dir('lib')}">
+      <include name="**/*.jar"/>
+    </fileset>
+  </path>
+  <taskdef classpathref="coverage" resource="tasks.properties"/>
+TASK_DEF
+    end
+
+    def modify_classpath(classpath)
+      classpath.insert @jar
+      classpath.insert @instrumented_dir
+    end
+
+    def instrument_task
+      return <<RESULT
+    <cobertura-instrument todir="#{@instrumented_dir}" datafile="#{@datafile}">
+        <fileset dir="#{@project.prod.output}">
+            <include name="**/*.class"/>
+        </fileset>
+    </cobertura-instrument>
+    <copy todir="#{@instrumented_dir}">
+      <fileset dir="#{@project.prod.output}" excludes="**/*.class"/>
+    </copy>
+RESULT
+    end
+
+    def sysproperty
+      return <<SYSPROPERTY
+<sysproperty key="net.sourceforge.cobertura.datafile" file="#{@datafile}" />
+SYSPROPERTY
+    end
+
+    def report_task(report_dir)
+      return <<REPORT
+    <cobertura-report srcdir="#{@project.src}" destdir="#{report_dir}" datafile="#{@datafile}"/>
+REPORT
+    end
+
+    def clean_instrumented_files
+      @instrumented_dir.delete
+    end
+  end
+
+end