kwala 0.9.0

data/lib/kwala/lib/strange_requires_detector.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby -w
+
+# Copyright (c) 2006, Ubiquitous Business Technology (http://ubit.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials provided
+#      with the distribution.
+#
+#    * Neither the name of Ubit nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# == Author
+# Michael Reinsch (mr@ubit.com)
+
+require File.dirname(__FILE__) + "/cycle_detector"   # for ReqWalker
+
+class Dir
+  def == (other)
+    case other
+    when String;  return path == other
+    when Dir;     return path == other.path
+    when FakeDir; return path == other.path
+    end
+    false
+  end
+
+  def is_subdir_of?(dir)
+    return path[0..dir.path.length-1] == dir.path
+  end
+
+  def cut(basedir)
+    path
+  end
+end
+
+
+class StrangeRequiresDetector
+
+  attr_writer :print_strategy
+
+  def initialize(printer)
+    @graph = Hash.new
+    @printer = printer
+    @file_filter = Proc.new do |files|
+      files.find_all do |f|
+        /tests\// !~ f && /extensions\// !~ f &&
+          /tools\// !~ f && /\/ms\// !~ f && /\/site\// !~f
+      end
+    end
+    @req_filter = Proc.new do |reqs|
+      reqs.find_all do |r|
+
+      end
+    end
+  end
+
+  def cut_base(filename, basename)
+    filename.gsub(/^#{basename}/, '')
+  end
+
+  def check(dir, basedir = "")
+    files = ReqWalker.find_ruby_files(dir)
+    @file_filter.call(files).each do |f|
+      ReqWalker.get_requires(f).each do |r|
+        r = ReqWalker.find_file(r)
+        if r && /\/lib\/ruby\// !~ r
+          f_base = Dir.new(File.dirname(f))
+          r_base = Dir.new(File.dirname(r))
+          # well, we assume that a directory models our "class category"...
+          if f_base != r_base
+            if r_base.is_subdir_of?(f_base)
+              @printer.subdir_requirement(cut_base(f,basedir), cut_base(r,basedir))
+            else
+              @printer.parent_dir_requirement(cut_base(f,basedir), cut_base(r,basedir))
+            end
+          end
+        end
+      end
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+  class STDOUTPrintStrategy
+    def subdir_requirement(from, to)
+      puts "yellow: #{from} -> #{to}"
+    end
+    def parent_dir_requirement(from, to)
+      puts "red   : #{from} -> #{to}"
+    end
+  end
+
+  require 'getoptlong'
+
+  srd = StrangeRequiresDetector.new(STDOUTPrintStrategy.new)
+  dir = "./"
+
+  begin
+    options = GetoptLong.new(
+                             ["-d","--dir", GetoptLong::REQUIRED_ARGUMENT]
+                             )
+
+    options.each do |opt,arg|
+      case opt
+      when "-d"
+        dir = arg
+      else
+        STDERR.puts "Unknown command #{ opt }"
+        exit 1
+      end
+    end
+  rescue => err
+    STDERR.puts "Error invalid command"
+    exit 1
+  end
+
+  srd.check(dir)
+
+end

data/lib/kwala/notification.rb

@@ -0,0 +1,45 @@
+
+class Notification
+  @@notifications = []
+
+  def self.context=(context)
+    @context = context
+  end 
+
+  def self.context
+    @context
+  end
+
+  def self.notify(event, result, data)
+    self.notifications.each { |n| n.notify(event, result, data) }
+  end
+
+  def self.add_notification(obj)
+    self.notifications << obj
+  end
+
+  def self.notifications
+    if @@notifications.empty?
+      Dir.glob(NOTIFICATION_DIR + "/*.rb").sort.each do |file|
+        begin
+          require file
+        rescue Exception => err
+          $stderr.puts "Notification error loading #{file}", err.class, err.message
+        end
+      end
+    end
+    @@notifications
+  end
+
+  def notify(event, result = nil, data = nil)
+    if self.respond_to?(event)
+      self.send(event, result, data, Notification.context)
+    else
+      undefined_event(event, result, data, Notification.context)
+    end
+  end
+
+  def undefined_event(event, result, data, context)
+  end
+
+end

data/lib/kwala/notifications/email.rb

@@ -0,0 +1,54 @@
+require 'net/smtp'
+
+class EmailNotification < Notification
+
+  def unit_test(result, data, context)
+    # TODO: Probably should move this to a configuration based
+    from_addr = ""
+    to_addr = [ "" ]
+    smtp_server = ""
+    smtp_port = 25
+
+    # Get the time and set the status msg
+    now = Time.now
+    status_msg = "Unit tests run #{result.to_s} at"
+
+    # just file name for now
+    data ||= {}
+    data = Array(data[:filtered_results]).map do |d|
+      d[:file_name]
+    end
+
+    if !data.empty?
+      failure_msg = <<-MSG
+Test files that reported failures:
+#{data.join("\n")}
+MSG
+    else
+      failure_msg = ''
+    end
+
+    # Create the SMTP envelope
+    msgstr = <<-END_OF_MESSAGE
+From: Kwala Continuous Integration <EMAIL>
+To: Edge Dev Mailing List <EMAIL>
+Subject: [Kwala] edge build #{context.vcs_num} #{result}
+Date: #{now.strftime("%a, %d %b %Y %X +0900")}
+Message-Id: <#{now.strftime("%m%d%Y%H%M%S")}@EMAIL>
+
+Result Summary:  #{result.to_s}
+See Results at https://BASEURL/kwala/
+
+#{failure_msg}
+
+Commit Info:
+#{context.vcs_info}
+    END_OF_MESSAGE
+
+    # Send the message
+    Net::SMTP.start(smtp_server, smtp_port) do |smtp|
+      smtp.send_message(msgstr, from_addr, *to_addr)
+    end
+  end
+
+end

data/lib/kwala/notifications/rss.rb

@@ -0,0 +1,151 @@
+require 'pstore'
+require 'rss/2.0'
+require 'rss/utils'
+
+class RSSNotification < Notification
+
+  def unit_test(result, data, context)
+    @test_results = data[:test_results]
+
+    update_pstore(context)
+    make_rss(context)
+  end
+
+  protected
+
+  PSTORE_FILE_NAME = 'prev_test_results.pstore'
+
+  RSS_FILE_NAME = 'unit_test_results.rss'
+
+  class UnitTestResult
+    attr_reader :filename, :test_results, :errors, :warnings, :first_seen
+    attr_accessor :last_seen
+
+    def initialize(result_hash, timestamp)
+      @filename = result_hash[:file_name]
+      @errors = result_hash[:sys_errors]
+      @warnings = result_hash[:warnings]
+      @first_seen = @last_seen = timestamp
+
+      @test_results = Hash.new
+      result_hash[:version].each do |r|
+        if !r[:test_results].empty?
+          @test_results[r[:version_name]] = r[:test_results]
+        end
+      end
+    end
+
+    def pass?
+      @errors.empty? && @warnings.empty? && @test_results.empty?
+    end
+
+    def ==(obj)
+      res = obj.kind_of?(UnitTestResult)
+      res &= obj.filename == @filename
+      res &= obj.errors == @errors
+      res &= obj.warnings == @warnings
+      res &= obj.test_results == @test_results
+      res
+    end
+
+    def to_rss_item(compare_timestamp)
+      if @last_seen < compare_timestamp
+        defect_status = "Fixed"
+      else
+        defect_status = "New"
+      end
+
+      item = RSS::Rss::Channel::Item.new
+      item.title = "#{@first_seen.strftime("%b %d, %H:%M")} - #{defect_status} defects in #{@filename}"
+      item.pubDate = @first_seen
+      item.description = defect_details_html
+      item
+    end
+
+    protected
+
+    def system_messages_html(messages, type)
+      details = ""
+      if !messages.empty?
+        details << "<h2>System #{type}s</h2>\n<pre>\n"
+        details << RSS::Utils.html_escape(messages.join)
+        details << "\n</pre>\n"
+      end
+      details
+    end
+
+    def test_result_html
+      details = ""
+      @test_results.each do |ruby_ver, defects|
+        details << "<h2>Test Results for #{ruby_ver}</h2>\n"
+        defects.each do |d|
+          details << "<pre>\n"
+          details << RSS::Utils.html_escape(d[:test_info])
+          details << "\n</pre>\n"
+        end
+      end
+      details
+    end
+
+    def defect_details_html
+      details = ""
+      details << test_result_html
+      details << system_messages_html(@errors, "Error")
+      details << system_messages_html(@warnings, "Warning")
+      details
+    end
+  end
+
+  def create_pstore(context)
+    PStore.new(File.join(context.output_directory, PSTORE_FILE_NAME))
+  end
+
+  def update_pstore(context)
+    create_pstore(context).transaction do |store|
+      run_timestamp = Time.now
+      del_timestamp = run_timestamp - 12*60*60 # 12 hours
+      prev_test_results = store.fetch(:prev_test_results, Hash.new)
+
+      prev_test_results.delete_if do |key, res|
+        res.last_seen <= del_timestamp
+      end
+
+      @test_results.each do |cur_res_hash|
+        cur_res = UnitTestResult.new(cur_res_hash, run_timestamp)
+        next if cur_res.pass?
+
+        prev_res = prev_test_results[cur_res.filename]
+        if prev_res.nil? || cur_res != prev_res
+          # new defects
+          prev_test_results[cur_res.filename] = cur_res
+        else
+          # same'ol defect
+          prev_res.last_seen = run_timestamp
+        end
+      end
+
+      store[:last_run_timestamp] = run_timestamp
+      store[:prev_test_results] = prev_test_results
+    end
+  end
+
+  def make_rss(context)
+    rss = RSS::Rss.new("2.0")
+    chan = RSS::Rss::Channel.new
+    chan.title = chan.description = "Unit Test Results for #{context.project_name}"
+    rss.channel = chan
+
+    create_pstore(context).transaction(true) do |store|
+      last_run_timestamp = store.fetch(:last_run_timestamp, 0)
+      test_results = store.fetch(:prev_test_results, Hash.new)
+
+      test_results.each do |key, res|
+        chan.items << res.to_rss_item(last_run_timestamp)
+      end
+    end
+
+    File.open(File.join(context.output_directory, RSS_FILE_NAME), "w") {|f| f.puts(rss.to_s) }
+  end
+
+
+end

data/lib/kwala/project_builder_utils.rb

@@ -0,0 +1,178 @@
+module ProjectBuilderUtils
+
+  def ProjectBuilderUtils.find_ruby_files(dir)
+    ruby_files = Array.new
+
+    Find.find(dir) do |path|
+      if File.directory?(path)
+        # Ignore all directories starting with .
+        if File.basename(path)[0] == ?. || File.basename(path) =~ /vendor/
+          Find.prune
+        else
+          next
+        end
+      elsif File.file?(path)
+        case path.to_s
+        when /\.rb$/
+          ruby_files << path
+        when /\.rb~$/
+          next
+        when ProjectBuilderUtils.contains_ruby_execution_command?(path)
+          ruby_files << path
+        else
+        end
+      end
+    end
+
+    ruby_files = ruby_files.sort
+  end
+
+  def ProjectBuilderUtils.strip_base_dir(base_dir, file)
+    m = /(#{base_dir})(.*)/.match(file)
+    m[2][1..-1]
+  end
+
+  def ProjectBuilderUtils.get_ruby_and_unit_test_files(dir=Dir.pwd)
+    ruby_files = ProjectBuilderUtils.find_ruby_files(dir)
+
+    # remove all test case files
+    test_files, ruby_files = ruby_files.partition do |f|
+      f =~ /\/(tc|ts)_.+\.rb$|.*_test.rb$/
+    end
+
+    # XXX: UGLY HACK TO AVOID SIMULATION
+    test_files.delete_if { |f| f =~ /test\/simulation\// }
+
+    [ruby_files.uniq, test_files.sort.uniq]
+  end
+
+  def ProjectBuilderUtils.clean_trailing_slash(dir)
+    if dir[dir.size - 1] == ?/
+      if dir.size > 1
+        dir = dir[0..dir.size - 2]
+      else
+        dir = "."
+      end
+    end
+    dir
+  end
+
+
+  def ProjectBuilderUtils.expand_template(template, data)
+    str = StringIO.new
+    template.expand(str, data)
+    str.string
+  end
+
+  def ProjectBuilderUtils.load_actions
+    Dir.glob(ACTION_DIR + "/*.rb").sort.each do |action_file|
+      require(action_file)
+    end
+  end
+
+  def ProjectBuilderUtils.contains_ruby_execution_command?(path)
+    File.open(path, "r") do |f|
+      return (f.read(1024).to_s =~ /^#!.*ruby/)
+    end
+  end
+
+
+  def ProjectBuilderUtils.expand_summary_template(data, project_name, summaries)
+    template = TemplateFile.new("#{TEMPLATE_DIR}/build_template.html")
+    data[:action_summaries] = summaries
+    ProjectBuilderUtils.expand_template(template, data)
+  end
+
+  def ProjectBuilderUtils.make_summary_report(context, summaries)
+    if context.vcs_num
+
+      context.amrita_data[:vcs] = {
+        :vcs_num => context.vcs_num,
+        :vcs_info => context.vcs_info
+      }
+    end
+    context.build_complete
+
+    exp_res = ProjectBuilderUtils.expand_summary_template(context.amrita_data, context.project_name, summaries)
+    if context.output_directory
+      sum_file = "#{context.output_directory}/index.html"
+      File.open(sum_file, "w") do |f|
+        f.puts exp_res
+      end
+    else
+      STDOUT.puts exp_res
+    end
+  end
+
+  # Pull this into better place
+  def ProjectBuilderUtils.calc_score(context, action_instances)
+    scores = action_instances.map { |a| a.score }
+    scores.compact!
+
+    # If action doesn't calculate score, just default to 1 for now
+    if !scores.empty?
+      total = scores.inject(0) { |s,v| s + v }
+
+      #    puts "Total : #{total} SIZE: #{scores.size}"
+      score = ((total / (scores.size * 10).to_f) * 10).ceil
+      img_num = ProjectBuilderUtils.image_for_score(score)
+      #    puts "!!!!!!!!!!!!!!!!!! SCORE : #{score} IMG #{img_num} !!!!!!!!!!!"
+    else
+      img_num = 1
+    end
+    # Mascot Driven Development!
+    context.amrita_data[:mdd] = Amrita.a(:src => "mdd/#{img_num}.png")
+  end
+
+  def ProjectBuilderUtils.image_for_score(score)
+    case score
+    when 8..10 : 1
+    when 6..7 : 2
+    when 4..5 : 3
+    when 3..2 : 4
+    else
+      5
+    end
+  end
+
+  def ProjectBuilderUtils.make_detailed_reports(context, action_instances)
+    if context.output_directory
+      action_instances.each do |action|
+        det_file, det_res = action.detailed_display(context)
+        if det_file
+          File.open(det_file, "w") do |f|
+            f.puts det_res
+          end
+        end
+      end
+    end
+
+    ProjectBuilderUtils.calc_score(context, action_instances)
+  end
+
+  # returns an array of the actions that were successfully built
+  def ProjectBuilderUtils.build_actions(action_instances, context)
+    success = Array.new
+
+    action_instances.each do |action|  
+      begin
+        action.build_action(context)
+        success << action
+      rescue KwalaAbortBuildException => err        
+        # We want to failed action, but stop the others
+        success << action
+        break
+      end
+    end    
+
+    success
+  end
+
+  def ProjectBuilderUtils.build_summaries(action_instances, context)
+    action_instances.map do |action|
+      { :summary => action.summary_display(context) }
+    end
+  end
+
+
+end