rscm 0.1.0

data/lib/rscm/starteam/starteam.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+require 'tempfile'
+require 'rscm/changes'
+require 'rscm/abstract_scm'
+require 'yaml'
+
+class Time
+  def to_rfc2822
+    utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+  end
+end
+
+module RSCM
+  # The RSCM StarTeam class requires that the following software be installed:
+  #
+  # * Java Runtime (1.4.2)
+  # * StarTeam SDK
+  # * Apache Ant (http://ant.apache.org/)
+  #
+  class StarTeam < AbstractSCM
+
+    attr_accessor :user_name, :password, :server_name, :server_port, :project_name, :view_name, :folder_name
+
+    def initialize(user_name=nil, password=nil, server_name=nil, server_port=nil, project_name=nil, view_name=nil, folder_name=nil)
+      @user_name, @password, @server_name, @server_port, @project_name, @view_name, @folder_name = user_name, password, server_name, server_port, project_name, view_name, folder_name
+    end
+
+    def name
+      "StarTeam"
+    end
+    
+    def changesets(checkout_dir, from_identifier=Time.epoch, to_identifier=Time.infinity, files=nil, &proc)
+      # just assuming it is a Time for now, may support labels later.
+      # the java class really wants rfc822 and not rfc2822, but this works ok anyway.
+      from = from_identifier.to_rfc2822
+      to = to_identifier.to_rfc2822      
+
+      changesets = java("getChangeSets(\"#{from}\";\"#{to}\")", &proc)
+      raise "changesets must be of type #{ChangeSets.name} - was #{changesets.class.name}" unless changesets.is_a?(::RSCM::ChangeSets)
+
+      # Just a little sanity check
+      if(changesets.latest)
+        latetime = changesets.latest.time
+        if(latetime < from_identifier || to_identifier < latetime)
+          raise "Latest time (#{latetime}) is not within #{from_identifier}-#{to_identifier}"
+        end
+      end
+      changesets
+    end
+
+    def checkout(checkout_dir, to_identifier, &proc)
+      # TODO: Take the to_identifier arg into consideration
+      files = java("checkout(\"#{checkout_dir}\")", &proc)
+      files
+    end
+    
+  private
+  
+    def cmd
+      rscm_jar = File.expand_path(File.dirname(__FILE__) + "../../../../ext/rscm.jar")
+      starteam_jars = Dir["#{ENV['RSCM_STARTEAM']}/Lib/*jar"].join(File::PATH_SEPARATOR)
+      ant_jars = Dir["#{ENV['ANT_HOME']}/lib/*jar"].join(File::PATH_SEPARATOR)
+      classpath = "#{rscm_jar}#{File::PATH_SEPARATOR}#{ant_jars}#{File::PATH_SEPARATOR}#{starteam_jars}"
+
+      "java -Djava.library.path=\"#{ENV['RSCM_STARTEAM']}#{File::SEPARATOR}Lib\" -classpath \"#{classpath}\" org.rubyforge.rscm.Main"
+    end
+
+    def java(m, &proc)
+      raise "The RSCM_STARTEAM environment variable must be defined and point to the StarTeam SDK directory" unless ENV['RSCM_STARTEAM']
+      raise "The ANT_HOME environment variable must be defined and point to the Ant installation directory" unless ENV['ANT_HOME']
+
+      clazz = "org.rubyforge.rscm.starteam.StarTeam"
+      ctor_args = "#{@user_name};#{@password};#{@server_name};#{@server_port};#{@project_name};#{@view_name};#{@folder_name}"
+
+#     Uncomment if you're not Aslak - to run against a bogus java class.
+#      clazz = "org.rubyforge.rscm.TestScm"
+#      ctor_args = "hubba;bubba"
+
+      command = "new #{clazz}(#{ctor_args}).#{m}"
+      tf = Tempfile.new("rscm_starteam")
+      tf.puts(command)
+      tf.close 
+      cmdline = "#{cmd} #{tf.path}"
+      IO.popen(cmdline) do |io|
+        yaml_source = io
+        if(block_given?)
+          yaml_source = ""
+          io.each_line do |line|
+            yield line
+            yaml_source << line << "\n"
+          end
+        else
+        end
+        YAML::load(yaml_source)
+      end
+    end
+
+  end
+end

data/lib/rscm/svn/svn.rb

@@ -0,0 +1,337 @@
+require 'rscm/abstract_scm'
+require 'rscm/path_converter'
+require 'rscm/line_editor'
+require 'rscm/svn/svn_log_parser'
+
+module RSCM
+
+  # RSCM implementation for Subversion.
+  #
+  # You need the svn/svnadmin executable on the PATH in order for it to work.
+  #
+  # NOTE: On Cygwin these have to be the win32 builds of svn/svnadmin and not the Cygwin ones.
+  class SVN < AbstractSCM
+    include FileUtils
+    include PathConverter
+    
+    attr_accessor :url
+    attr_accessor :path
+
+    def initialize(url=nil, path="")
+      @url, @path = url, path
+    end
+
+    def name
+      "Subversion"
+    end
+
+    def add(checkout_dir, relative_filename)
+      svn(checkout_dir, "add #{relative_filename}")
+    end
+
+    def transactional?
+      true
+    end
+
+    def checkout(checkout_dir, to_identifier=nil)
+      checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
+      mkdir_p(checkout_dir)
+      checked_out_files = []
+      path_regex = /^[A|D|U]\s+(.*)/
+      if(checked_out?(checkout_dir))
+        svn(checkout_dir, update_command(to_identifier)) do |line|
+          if(line =~ path_regex)
+            absolute_path = "#{checkout_dir}/#{$1}"
+            relative_path = $1.chomp
+            relative_path = relative_path.gsub(/\\/, "/") if WINDOWS
+            checked_out_files << relative_path
+            yield relative_path if block_given?
+          end
+        end
+      else
+        svn(checkout_dir, checkout_command(checkout_dir, to_identifier)) do |line|
+          if(line =~ path_regex)
+            native_absolute_path = $1
+            native_checkout_dir = $1
+            absolute_path = PathConverter.nativepath_to_filepath($1)
+            native_checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
+            if(File.exist?(absolute_path) && !File.directory?(absolute_path))
+              relative_path = native_absolute_path[native_checkout_dir.length+1..-1].chomp
+              relative_path = relative_path.gsub(/\\/, "/") if WINDOWS
+              checked_out_files << relative_path
+              yield relative_path if block_given?
+            end
+          end
+        end
+      end
+      checked_out_files
+    end
+
+    def checkout_commandline
+      "svn checkout #{revision_option(nil)}"
+    end
+
+    def update_commandline
+      "svn update #{url} #{checkout_dir}"
+    end
+
+    def uptodate?(checkout_dir, from_identifier)
+      if(!checked_out?(checkout_dir))
+        false
+      else
+        lr = local_revision(checkout_dir)
+        hr = head_revision(checkout_dir)
+        lr == hr
+      end
+    end
+
+    def local_revision(checkout_dir)
+      local_revision = nil
+      svn(checkout_dir, "info") do |line|
+        if(line =~ /Revision: ([0-9]*)/)
+          return $1.to_i
+        end
+      end
+    end
+
+    def head_revision(checkout_dir)
+      cmd = "svn log #{repourl} -r HEAD"
+      with_working_dir(checkout_dir) do
+        safer_popen(cmd) do |stdout|
+          parser = SVNLogParser.new(stdout, path, checkout_dir)
+          changesets = parser.parse_changesets
+          changesets[0].revision.to_i
+        end
+      end
+    end
+
+    def commit(checkout_dir, message)
+      svn(checkout_dir, commit_command(message))
+      # We have to do an update to get the local revision right
+      svn(checkout_dir, "update")
+    end
+
+    def label(checkout_dir)
+      local_revision(checkout_dir).to_s
+    end
+
+    def diff(checkout_dir, change, &block)
+      with_working_dir(checkout_dir) do
+        cmd = "svn diff -r #{change.previous_revision}:#{change.revision} #{url}/#{change.path}"
+        safer_popen(cmd) do |io|
+          return(yield(io))
+        end
+      end
+    end
+
+    def can_create?
+      local?
+    end
+
+    def exists?
+      if(local?)
+        File.exists?("#{svnrootdir}/db")
+      else
+        # Do a simple command over the network
+        # If the repo/path doesn't exist, we'll get zero output
+        # on stdout (and an error msg on std err).
+        exists = false
+        cmd = "svn log #{url} -r HEAD"
+        IO.popen(cmd) do |stdout|
+          stdout.each_line do |line|
+            exists = true
+          end
+        end
+        exists
+      end
+    end
+
+    def supports_trigger?
+      local?
+    end
+
+    def create      
+      native_path = PathConverter.filepath_to_nativepath(svnrootdir, true)
+      mkdir_p(PathConverter.nativepath_to_filepath(native_path))
+      svnadmin(svnrootdir, "create #{native_path}")
+    end
+
+    def install_trigger(trigger_command, damagecontrol_install_dir)
+      if (WINDOWS)
+        install_win_trigger(trigger_command, damagecontrol_install_dir)
+      else
+        install_unix_trigger(trigger_command, damagecontrol_install_dir)
+      end
+    end
+    
+    def uninstall_trigger(trigger_command, trigger_files_checkout_dir)
+      File.comment_out(post_commit_file, /#{Regexp.escape(trigger_command)}/, nil)
+    end
+    
+    def trigger_installed?(trigger_command, trigger_files_checkout_dir)
+      return false unless File.exist?(post_commit_file)
+      not_already_commented = LineEditor.comment_out(File.new(post_commit_file), /#{Regexp.escape(trigger_command)}/, "# ", "")
+      not_already_commented
+    end
+    
+    def import(dir, message)
+      import_cmd = "import #{url} -m \"#{message}\""
+      svn(dir, import_cmd)
+    end
+
+    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity, files=nil)
+      # Return empty changeset if the requested revision doesn't exist yet.
+      return ChangeSets.new if(from_identifier.is_a?(Integer) && head_revision(checkout_dir) < from_identifier)
+
+      checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
+      changesets = nil
+      command = "svn #{changes_command(from_identifier, to_identifier, files)}"
+      yield command if block_given?
+
+      with_working_dir(checkout_dir) do
+        safer_popen(command) do |stdout|
+          parser = SVNLogParser.new(stdout, path, checkout_dir)
+          changesets = parser.parse_changesets
+        end
+      end
+      changesets
+    end
+    
+    # url pointing to the root of the repo
+    def repourl
+      last = (path.nil? || path == "") ? -1 : -(path.length)-2
+      url[0..last]
+    end
+
+    def checked_out?(checkout_dir)
+      rootentries = File.expand_path("#{checkout_dir}/.svn/entries")
+      result = File.exists?(rootentries)
+      result
+    end
+
+  private
+
+    def install_unix_trigger(trigger_command, damagecontrol_install_dir)
+      post_commit_exists = File.exists?(post_commit_file)
+      mode = post_commit_exists ? File::APPEND|File::WRONLY : File::CREAT|File::WRONLY
+      begin
+        File.open(post_commit_file, mode) do |file|
+          file.puts("#!/bin/sh") unless post_commit_exists 
+          file.puts("#{trigger_command}\n" )
+        end
+        system("chmod g+x #{post_commit_file}")
+      rescue
+        raise "Didn't have permission to write to #{post_commit_file}. " +
+              "Try to manually add the following line:\n\n#{trigger_command}\n\n" +
+              "Finally make it executable with chmod g+x #{post_commit_file}\n\n"
+      end
+    end
+    
+    def install_win_trigger(trigger_command, damagecontrol_install_dir)
+      post_commit_exists = File.exists?(post_commit_file)
+      mode = post_commit_exists ? File::APPEND|File::WRONLY : File::CREAT|File::WRONLY
+      File.open(post_commit_file, mode) do |file|
+        file.puts("#{trigger_command}\n" )
+      end
+    end
+    
+    def svnrootdir
+      last = (path.nil? || path == "") ? -1 : -(path.length)-2
+      result = url["file://".length..last]
+      # for windows, turn /c:/blabla into c:/blabla"
+      if(result =~ /^\/[a-zA-Z]:/)
+        result = result[1..-1]
+      end
+      result
+    end
+
+    def svnadmin(dir, cmd, &proc)
+      svncommand("svnadmin", dir, cmd, &proc)
+    end
+
+    def svn(dir, cmd, &proc)
+      svncommand("svn", dir, cmd, &proc)
+    end
+
+    def svncommand(executable, dir, cmd, &proc)
+      command_line = "#{executable} #{cmd}"
+      dir = File.expand_path(dir)
+      with_working_dir(dir) do
+        safer_popen(command_line) do |stdout|
+          stdout.each_line do |line|
+            yield line if block_given?
+          end
+        end
+      end
+    end
+    
+    def checkout_command(checkout_dir, to_identifier)
+      checkout_dir = "\"#{checkout_dir}\""
+      "checkout #{url} #{checkout_dir} #{revision_option(nil,to_identifier)}"
+    end
+
+    def update_command(to_identifier)
+      "update #{revision_option(nil,to_identifier)}"
+    end
+    
+    def changes_command(from_identifier, to_identifier, files)
+      # http://svnbook.red-bean.com/svnbook-1.1/svn-book.html#svn-ch-3-sect-3.3
+      # file_list = files.join('\n')
+# WEIRD cygwin bug garbles this!?!?!?!
+      cmd = "log --verbose #{revision_option(from_identifier, to_identifier)} #{url}"
+      cmd
+    end
+
+    def revision_option(from_identifier, to_identifier)
+      from = nil
+      if(from_identifier.is_a?(Time))
+        from = svndate(from_identifier)
+      else
+        from = from_identifier
+      end
+
+      to = nil
+      if(to_identifier.is_a?(Time))
+        to = svndate(to_identifier)
+      else
+        to = to_identifier
+      end
+
+      revision_option = nil
+      if(from && to.nil?)
+        revision_option = "--revision #{from}:HEAD"
+      elsif(from.nil? && to)
+        revision_option = "--revision #{to}"
+      elsif(from.nil? && to.nil?)
+        revision_option = ""
+      elsif(from && to)
+        revision_option = "--revision #{from}:#{to}"
+      end
+      revision_option
+    end
+    
+    def svndate(time)
+      return nil unless time
+      time.utc.strftime("\"{%Y-%m-%d %H:%M:%S\"}")
+    end
+
+    def commit_command(message)
+      "commit -m \"#{message}\""
+    end
+    
+    def local?
+      if(url =~ /^file:/)
+        return true
+      else
+        return false
+      end
+    end
+
+    def post_commit_file
+      # We actualy need to use the .cmd when on cygwin. The cygwin svn post-commit
+      # hook is hosed. We'll be relying on native windows
+      WINDOWS ? "#{svnrootdir}/hooks/post-commit.cmd" : "#{svnrootdir}/hooks/post-commit"
+    end
+    
+  end
+end

data/lib/rscm/svn/svn_log_parser.rb

@@ -0,0 +1,134 @@
+require 'rscm/parser'
+require 'rscm/changes'
+
+module RSCM
+
+  class SVNLogParser
+    def initialize(io, path, checkout_dir)
+      @io = io
+      @changeset_parser = SVNLogEntryParser.new(path, checkout_dir)
+    end
+    
+    def parse_changesets(&line_proc)
+      # skip over the first ------
+      @changeset_parser.parse(@io, true, &line_proc)
+      changesets = ChangeSets.new
+      while(!@io.eof?)
+        changeset = @changeset_parser.parse(@io, &line_proc)
+        if(changeset)
+          changesets.add(changeset)
+        end
+      end
+      changesets
+    end
+  end
+  
+  class SVNLogEntryParser < Parser
+
+    def initialize(path, checkout_dir)
+      super(/^------------------------------------------------------------------------/)
+      @path = path ? path : ""
+      @checkout_dir = checkout_dir
+    end
+
+    def parse(io, skip_line_parsing=false, &line_proc)
+      # We have to trim off the last newline - it's not meant to be part of the message
+      changeset = super
+      changeset.message = changeset.message[0..-2] if changeset
+      changeset
+    end
+
+  protected
+
+    def parse_line(line)
+      if(@changeset.nil?)
+        parse_header(line)
+      elsif(line.strip == "")
+        @parse_state = :parse_message
+      elsif(line =~ /Changed paths/)
+        @parse_state = :parse_changes
+      elsif(@parse_state == :parse_changes)
+        change = parse_change(line)
+        if change
+          # This unless won't work for new directories
+          fullpath = "#{@checkout_dir}/#{change.path}"
+          @changeset << change unless File.directory?(fullpath)
+        end
+      elsif(@parse_state == :parse_message)
+        @changeset.message << line.chomp << "\n"
+      end
+    end
+
+    def next_result
+      result = @changeset
+      @changeset = nil
+      result
+    end
+
+  private
+  
+    STATES = {"M" => Change::MODIFIED, "A" => Change::ADDED, "D" => Change::DELETED}
+
+    def parse_header(line)
+      @changeset = ChangeSet.new
+      @changeset.message = ""
+      revision, developer, time, the_rest = line.split("|")
+      @changeset.revision = revision.strip[1..-1].to_i unless revision.nil?
+      @changeset.developer = developer.strip unless developer.nil?
+      @changeset.time = parse_time(time.strip) unless time.nil?
+    end
+    
+    def parse_change(line)
+      change = Change.new
+      path_from_root = nil
+      if(line =~ /^   [M|A|D|R] ([^\s]+) \(from (.*)\)/)
+        path_from_root = $1
+        change.status = Change::MOVED
+      elsif(line =~ /^   ([M|A|D]) (.+)$/)
+        status, path_from_root = line.split
+        change.status = STATES[status]
+      else
+        raise "could not parse change line: '#{line}'"
+      end
+
+      path_from_root.gsub!(/\\/, "/")
+      return nil unless path_from_root =~ /^\/#{@path}/
+      if(@path.length+1 == path_from_root.length)
+        change.path = path_from_root[@path.length+1..-1]
+      else
+        change.path = path_from_root[@path.length+2..-1]
+      end
+      change.revision = @changeset.revision
+      # http://jira.codehaus.org/browse/DC-204
+      change.previous_revision = change.revision.to_i - 1;
+      change
+    end
+
+    def parse_time(svn_time)
+      if(svn_time =~ /(.*)-(.*)-(.*) (.*):(.*):(.*) (\+|\-)([0-9]*) (.*)/)
+        year  = $1.to_i
+        month = $2.to_i
+        day   = $3.to_i
+        hour  = $4.to_i
+        min   = $5.to_i
+        sec   = $6.to_i
+        time = Time.utc(year, month, day, hour, min, sec)
+        
+        time = adjust_offset(time, $7, $8)
+      else
+        raise "unexpected time format"
+      end
+    end
+
+    def adjust_offset(time, sign, offset)
+      hour_offset = offset[0..1].to_i
+      min_offset = offset[2..3].to_i
+      sec_offset = 3600*hour_offset + 60*min_offset
+      sec_offset = -sec_offset if(sign == "+")
+      time += sec_offset
+      time
+    end
+    
+  end
+
+end