damagecontrol 0.5.0

data/lib/damagecontrol/diff_parser.rb

@@ -0,0 +1,153 @@
+module DamageControl
+
+  class DiffParser
+
+    DIFF_START = /@@ \-([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@/
+  
+    def parse_diffs(io)
+      diffs = []
+      diff = nil
+      io.each_line do |line|
+        if(line =~ DIFF_START)
+          diffs << diff if diff
+          diff = Diff.new($1.to_i, $2.to_i, $3.to_i, $4.to_i)
+        elsif(diff)
+          diff << line
+        end
+      end
+      diffs << diff if diff
+      diffs.each do |diff|
+        diff.parse
+      end
+      diffs
+    end  
+  end
+
+  # Represents a unified diff section in a diff file.
+  class Diff
+    attr_reader :minus, :nminus, :plus, :nplus, :removed_range
+
+    # Create a new Diff. +minus+ and +plus+ represent the number of
+    # removed and added lines.
+    def initialize(minus, nminus, plus, nplus)
+      @minus, @nminus, @plus, @nplus = minus, nminus, plus, nplus
+      @lines = []
+    end
+    
+    def <<(line)
+      @lines << line
+    end
+    
+    def line_count
+      @lines.length
+    end
+    
+    def[](n)
+      @lines[n]
+    end
+    
+    def parse
+      prev = nil
+      @lines.each do |line|
+        prefix_length = 1
+        suffix_len = 0
+        if(prev && prev.removed? && line.added?)
+          a = line[1..-1]
+          b = prev[1..-1]
+          prefix_length = a.common_prefix_length(b)+1
+          suffix_len = a.reverse.common_prefix_length(b.reverse)
+          # prevent prefix/suffix having overlap,
+          suffix_len = min(suffix_len, min(line.length,prev.length)-prefix_length)
+          remove_infix_length = prev.length - (prefix_length+suffix_len)
+          add_infix_length = line.length - (prefix_length+suffix_len)
+          oversize_change = remove_infix_length*100/prev.length>33 || add_infix_length*100/line.length>33
+
+          if prefix_length==1 && suffix_len==0 || remove_infix_length<=0 || oversize_change
+          else
+            prev.removed_range = (prefix_length..prefix_length+remove_infix_length-1)
+          end
+
+          if prefix_length==1 && suffix_len==0 || add_infix_length<=0 || oversize_change
+          else
+            line.added_range = (prefix_length..prefix_length+add_infix_length-1)
+          end
+        end
+        prev = line
+      end
+    end
+    
+    def accept(visitor)
+      @lines.each do |line|
+        visitor.visitLine(line)
+      end
+    end
+
+  private
+  
+    def min(a, b)
+      a<b ? a : b
+    end
+  end
+
+end
+
+# Extra methods added to String to ease diff manipulation
+class String
+  attr_accessor :removed_range
+  attr_accessor :added_range
+
+  def removed?
+    (self =~ /\-/) == 0
+  end
+
+  def removed
+    removed_range ? self[removed_range] : nil
+  end
+
+  def added?
+    (self =~ /\+/) == 0
+  end
+
+  def added
+    added_range ? self[added_range] : nil
+  end
+
+  def prefix
+    self[0..range.first-1]
+  end
+
+  def suffix
+    self[range.last+1..-1]
+  end
+
+  def content
+    "\n" == self ? "\n" : self[1..-1]
+  end
+
+  def common_prefix_length(o)
+    length = 0
+    each_byte do |char|
+      break unless o[length] == char
+      length = length + 1
+    end
+    length
+  end
+
+private
+
+  def range
+    removed? ? removed_range : added_range
+  end
+
+end
+
+# Add visiting capabilities to Array
+class Array
+  def accept(visitor)
+    each do |d| 
+      visitor.visitDiff(d)
+      d.accept(visitor)
+      visitor.visitDiffEnd(d)
+    end
+  end
+end

data/lib/damagecontrol/directories.rb

@@ -0,0 +1,126 @@
+require 'fileutils'
+require 'rscm/path_converter'
+require 'rscm/abstract_scm' # for the modified Time.to_s
+
+module DamageControl
+
+  # This class knows about locations of various files and directories.
+  #
+  module Directories
+    include FileUtils
+
+    def project_names
+      result = Dir["#{basedir}/*/project.yaml"].collect do |f| 
+        File.basename(File.dirname(f))
+      end
+      result.sort
+    end
+    module_function :project_names
+    
+    def checkout_dir(project_name)
+      "#{project_dir(project_name)}/checkout"
+    end
+    module_function :checkout_dir
+
+    # File containing list of files *currently* being
+    # checked out.
+    def checkout_list_file(project_name)
+      "#{project_dir(project_name)}/checkout_list.txt"
+    end
+    module_function :checkout_list_file
+
+    def changeset_dir(project_name, changeset_identifier)
+      "#{changesets_dir(project_name)}/#{changeset_identifier.to_s}"
+    end
+    module_function :changeset_dir
+
+    def builds_dir(project_name, changeset_identifier)
+      "#{changeset_dir(project_name, changeset_identifier)}/builds"
+    end
+    module_function :builds_dir
+
+    def build_dirs(project_name, changeset_identifier)
+      Dir["#{builds_dir(project_name, changeset_identifier)}/*"]
+    end
+    module_function :build_dirs
+    
+    # Dir for a build created at time +time+
+    def build_dir(project_name, changeset_identifier, time)
+      "#{builds_dir(project_name, changeset_identifier)}/#{time.to_s}"
+    end
+    module_function :build_dir
+    
+    # File where stdout for the build command is written
+    def stdout(project_name, changeset_identifier, time)
+      "#{build_dir(project_name, changeset_identifier, time)}/stdout.log"
+    end
+    module_function :stdout
+    
+    # File where stderr for the build command is written
+    def stderr(project_name, changeset_identifier, time)
+      "#{build_dir(project_name, changeset_identifier, time)}/stderr.log"
+    end
+    module_function :stderr
+    
+    # File where the exit code for the build command execution is stored
+    def build_exit_code_file(project_name, changeset_identifier, time)
+      "#{build_dir(project_name, changeset_identifier, time)}/exit_code"
+    end
+    module_function :build_exit_code_file
+    
+    # File where the pid for the build command execution is stored
+    def build_pid_file(project_name, changeset_identifier, time)
+      "#{build_dir(project_name, changeset_identifier, time)}/pid"
+    end
+    module_function :build_pid_file
+    
+    # File containing the build command for a build created at time +time+
+    def build_command_file(project_name, changeset_identifier, time)
+      "#{build_dir(project_name, changeset_identifier, time)}/command"
+    end
+    module_function :build_command_file
+
+    def changesets_dir(project_name)
+      "#{project_dir(project_name)}/changesets"
+    end
+    module_function :changesets_dir
+
+    def changesets_rss_file(project_name)
+      "#{changesets_dir(project_name)}/changesets.rss"
+    end
+    module_function :changesets_rss_file
+
+    def diff_file(project_name, changeset, change)
+      "#{changesets_dir(project_name)}/#{changeset.identifier.to_s}/diffs/#{change.path}.diff"
+    end
+    module_function :diff_file
+
+    def trigger_checkout_dir(project_name)
+      "#{project_dir(project_name)}/trigger_checkout"
+    end
+    module_function :trigger_checkout_dir
+
+    def project_config_file(project_name)
+      "#{project_dir(project_name)}/project.yaml"
+    end
+    module_function :project_config_file
+
+    def project_dir(project_name)
+      "#{basedir}/#{project_name}"
+    end
+    module_function :project_dir
+
+    def basedir
+      if(ENV['DAMAGECONTROL_HOME'])
+        ENV['DAMAGECONTROL_HOME']
+      elsif(WINDOWS)
+        RSCM::PathConverter.nativepath_to_filepath("#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}/.damagecontrol").gsub(/\\/, "/")
+      else
+        "#{ENV['HOME']}/.damagecontrol"
+      end
+    end
+    module_function :basedir
+
+  end
+  
+end

data/lib/damagecontrol/poller.rb

@@ -0,0 +1,72 @@
+require 'rscm/logging'
+require 'rscm/time_ext'
+require 'damagecontrol/project'
+
+module DamageControl
+  # Polls all projects in intervals.
+  class Poller
+    attr_reader :projects
+
+    # Creates a new poller. Takes a block that will
+    # receive |project, changesets| each time new
+    # +changesets+ are found in a polled +project+
+    def initialize(sleeptime=60, &proc)
+      @projects = []
+      @sleeptime = sleeptime
+      @proc = proc
+    end
+
+    # Adds a project to poll. If the project is already added it is replaced
+    # with then new one, otherwise appended to the end.
+    def add_project(project)
+      index = @projects.index(project) || @projects.length
+      @projects[index] = project
+    end
+    
+    # Polls all registered projects and persists RSS, changesets and diffs to disk.
+    # If a block is passed, the project and the changesets will be yielded to the block
+    # for each new changesets object.
+    def poll
+      @projects.each do |project|
+        begin
+          if(project.scm_exists?)
+            project.poll do |changesets|
+              if(changesets.empty?)
+                Log.info "No changesets for #{project.name}"
+              else
+                @proc.call(project, changesets)
+              end
+            end
+          end
+        rescue => e
+          $stderr.puts "Error polling #{project.name}"
+          $stderr.puts e.message
+          $stderr.puts "  " + e.backtrace.join("  \n")
+        end
+      end
+    end
+    
+    # Runs +poll+ in a separate thread.
+    def start
+      add_all_projects
+      @t = Thread.new do
+        while(true)
+          poll
+          sleep(@sleeptime)
+        end
+      end
+    end
+    
+    # Stops thread after a +start+.
+    def stop
+      @t.kill if @t && @t.alive?
+    end
+
+    # Adds all projects
+    def add_all_projects
+      Project.find_all.each do |project|
+        add_project(project)
+      end
+    end    
+  end
+end

data/lib/damagecontrol/project.rb

@@ -0,0 +1,213 @@
+require 'fileutils'
+require 'yaml'
+require 'rscm'
+require 'damagecontrol/build'
+require 'damagecontrol/directories'
+require 'damagecontrol/diff_parser'
+require 'damagecontrol/diff_htmlizer'
+require 'damagecontrol/scm_web'
+require 'damagecontrol/tracker'
+require 'damagecontrol/visitor/yaml_persister'
+require 'damagecontrol/visitor/diff_persister'
+require 'damagecontrol/visitor/rss_writer'
+
+module DamageControl
+  # Represents a project with associated SCM, Tracker and SCMWeb
+  class Project
+
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :home_page
+
+    attr_accessor :scm
+    attr_accessor :tracker
+    attr_accessor :scm_web
+
+    # How long to sleep between each changesets invocation for non-transactional SCMs  
+    attr_accessor :quiet_period
+
+    attr_accessor :build_command
+
+    # Loads the project with the given +name+.
+    def Project.load(name)
+      config_file = Directories.project_config_file(name)
+      Log.info "Loading project from #{config_file}"
+      File.open(config_file) do |io|
+        YAML::load(io)
+      end
+    end
+
+    # Loads all projects
+    def Project.find_all
+      Directories.project_names.collect do |name|
+        Project.load(name)
+      end
+    end
+  
+    def initialize(name=nil)
+      @name = name
+      @scm = nil
+      @tracker = Tracker::Null.new
+      @scm_web = SCMWeb::Null.new
+    end
+    
+    # Saves the state of this project to persistent store (YAML)
+    def save
+      f = project_config_file
+      FileUtils.mkdir_p(File.dirname(f))
+      File.open(f, "w") do |io|
+        YAML::dump(self, io)
+      end
+      
+      REGISTRY.poller.add_project(self) if REGISTRY
+    end
+    
+    # Path to file containing pathnames of latest checked out files.
+    def checkout_list_file
+      Directories.checkout_list_file(name)
+    end
+    
+    # Checks out files to project's checkout directory.
+    # Writes the checked out files to +checkout_list_file+.
+    # The +changeset_identifier+ parameter is a String or a Time
+    # representing a changeset.
+    def checkout(changeset_identifier)
+      File.open(checkout_list_file, "w") do |f|
+        scm.checkout(checkout_dir, changeset_identifier) do |file_name|
+          f << file_name << "\n"
+          f.flush
+        end
+      end
+    end
+
+    # Polls SCM for new changesets and yields them to the given block.
+    def poll(from_if_first_poll=Time.epoch)
+      start = Time.now
+      from = next_changeset_identifier || from_if_first_poll
+      
+      Log.info "Getting changesets for #{name} from #{from} (retrieved from #{checkout_dir})"
+      changesets = @scm.changesets(checkout_dir, from)
+      if(!changesets.empty? && !@scm.transactional?)
+        # We're dealing with a non-transactional SCM (like CVS/StarTeam/ClearCase,
+        # unlike Subversion/Monotone). Sleep a little, get the changesets again.
+        # When the changesets are not changing, we can consider the last commit done
+        # and the quiet period elapsed. This is not 100% failsafe, but will work
+        # under most circumstances. In the worst case, we'll miss some files in
+        # the changesets, but they will be part of the next changeset (on next poll).
+        commit_in_progress = true
+        while(commit_in_progress)
+          @quiet_period ||= 5
+          Log.info "Sleeping for #{@quiet_period} seconds since #{name}'s SCM (#{@scm.name}) is not transactional."
+          sleep @quiet_period
+          next_changesets = @scm.changesets(checkout_dir, from)
+          commit_in_progress = changesets != next_changesets
+          changesets = next_changesets
+        end
+        Log.info "Quiet period elapsed for #{name}"
+      end
+      Log.info "Got changesets for #{@name} in #{Time.now.difference_as_text(start)}"
+      yield changesets
+    end
+
+    # Returns the identifier (int label or time) that should be used to get the next (unrecorded)
+    # changeset. This is the identifier *following* the latest recorded changeset. 
+    # This identifier is determined by looking at the directory names under 
+    # +changesets_dir+. If there are none, this method returns nil.
+    def next_changeset_identifier(d=changesets_dir)
+      # See String extension at top of this file.
+      latest_identifier = DamageControl::Visitor::YamlPersister.new(d).latest_identifier
+      latest_identifier ? latest_identifier + 1 : nil
+    end
+    
+    # Where RSS is written.
+    def changesets_rss_file
+      Directories.changesets_rss_file(name)
+    end
+
+    def checked_out?
+      @scm.checked_out?(checkout_dir)
+    end
+    
+    def exists?
+      File.exists?(project_config_file)
+    end
+
+    def scm_exists?
+      scm.exists?
+    end
+
+    def checkout_dir
+      Directories.checkout_dir(name)
+    end
+    
+    def delete_working_copy
+      File.delete(checkout_dir)
+    end
+
+    def changesets_rss_exists?
+      File.exist?(changesets_rss_file)
+    end
+
+    def changesets_dir
+      Directories.changesets_dir(name)
+    end
+    
+    def changesets(changeset_identifier, prior)
+      changesets_persister.load_upto(changeset_identifier, prior)
+    end
+
+    def changeset_identifiers
+      changesets_persister.identifiers
+    end
+    
+    def latest_changeset_identifier
+      changesets_persister.latest_identifier
+    end
+    
+    def delete
+      File.delete(Directories.project_dir(name))
+    end
+    
+    def == (o)
+      return false unless o.is_a?(Project)
+      name == o.name
+    end
+
+    def changesets_persister
+      DamageControl::Visitor::YamlPersister.new(changesets_dir)
+    end
+    
+    # Creates, persists and executes a build for the changeset with the given 
+    # +changeset_identifier+.
+    # Should be called with a block of arity 1 that will receive the build.
+    def build(changeset_identifier)
+      scm.checkout(checkout_dir, changeset_identifier)
+      build = Build.new(name, changeset_identifier, Time.now.utc)
+      yield build
+    end
+
+    # Returns an array of existing builds for the given +changeset+.
+    def builds(changeset_identifier)
+      Directories.build_dirs(name, changeset_identifier).collect do |dir|
+        # The dir's basename will always be a Time
+        Build.new(name, changeset_identifier, File.basename(dir).to_identifier)
+      end
+    end
+
+    # Returns the latest build.
+    def latest_build
+      changeset_identifiers.reverse.each do |changeset_identifier|
+        builds = builds(changeset_identifier)
+        return builds[-1] unless builds.empty?
+      end
+      nil
+    end
+
+  private
+
+    def project_config_file
+      Directories.project_config_file(name)
+    end
+
+  end
+end

data/lib/damagecontrol/project_dependencies.rb

@@ -0,0 +1,8 @@
+require 'damagecontrol/project'
+
+module DamageControl
+  class Project
+    def add_dependency(project)
+    end
+  end
+end

data/lib/damagecontrol/scm_web.rb

@@ -0,0 +1,50 @@
+require 'rscm/path_converter'
+
+module DamageControl
+  module SCMWeb
+
+    class Null
+      def change_url(change, anchor=false)
+        change.path
+      end
+
+      def changeset_url(changeset, anchor=false)
+        "http://foo.bar/"
+      end
+    end
+
+    class ViewCVS
+      attr_accessor :baseurl
+
+      def initialize(baseurl)
+        @baseurl = baseurl
+      end
+
+      def url
+        RSCM::PathConverter.ensure_trailing_slash(baseurl)
+      end
+
+      def change_url(change, anchor=false)
+        result = nil
+        if(change.previous_revision)
+          result = "#{url}#{change.path}?r1=#{change.previous_revision}&r2=#{change.revision}"
+        else
+          # point to the viewcvs (rev) and fisheye (r) revisions (no diff view)
+          result = "#{url}#{change.path}?rev=#{change.revision}&r=#{change.revision}"
+        end
+        anchor ? "<a href=\"#{result}\">#{change.path}</a>" : result
+      end
+
+      def changeset_url(changeset, anchor=false)
+        url
+      end
+    end
+
+    class Fisheye < ViewCVS
+      def changeset_url(changeset, anchor=false)
+        # TODO: link to their faked CVS changesets (or proper SVN ones when that happens).
+      end
+    end
+
+  end
+end

data/lib/damagecontrol/standard_persister.rb

@@ -0,0 +1,49 @@
+require 'rss/maker'
+require 'rscm/logging'
+require 'rscm/time_ext'
+require 'damagecontrol/project'
+
+module DamageControl
+  # Persists standard stuff like changesets, diffs and RSS.
+  # Typically used within a block passed to a Poller. See App.
+  class StandardPersister
+    
+    # Save the changesets to disk as YAML
+    def save_changesets(project, changesets)
+      Log.info "Saving changesets for #{project.name}"
+      changesets.accept(project.changesets_persister)
+    end
+    
+    # Get the diffs for each change and save them.
+    def save_diffs(project, changesets)
+      Log.info "Getting diffs for #{project.name}"
+      dp = DamageControl::Visitor::DiffPersister.new(project.scm, project.name)
+      changesets.accept(dp)
+      Log.info "Saved diffs for #{project.name}"
+    end
+    
+    # Save RSS to disk. The RSS spec says max 15 items in a channel,
+    # (http://www.chadfowler.com/ruby/rss/)
+    # We'll get upto the latest 15 changesets and turn them into RSS.
+    def save_rss(project)
+      Log.info "Generating RSS for #{project.name}"
+      last_15_changesets = project.changesets_persister.load_upto(project.changesets_persister.latest_identifier, 15)
+      RSS::Maker.make("2.0") do |rss|
+        FileUtils.mkdir_p(File.dirname(project.changesets_rss_file))
+        File.open(project.changesets_rss_file, "w") do |io|
+          rss_writer = DamageControl::Visitor::RssWriter.new(
+            rss,
+            "Changesets for #{@name}",
+            "http://localhost:4712/", # TODO point to web version of changeset
+            project.description, 
+            project.tracker || Tracker::Null.new, 
+            project.scm_web || SCMWeb::Null.new        
+          )
+          last_15_changesets.accept(rss_writer)
+          io.write(rss.to_rss)
+        end
+      end
+      Log.info "Saved RSS for #{project.name} to #{project.changesets_rss_file}"
+    end
+  end
+end