rscm 0.2.1.1404 → 0.3.0

data/lib/rscm/scm/star_team.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 require 'tempfile'
-require 'rscm/changes'
-require 'rscm/abstract_scm'
+require 'rscm/revision'
+require 'rscm/base'
 require 'yaml'
 
 class Time
@@ -17,8 +17,8 @@ module RSCM
   # * StarTeam SDK
   # * Apache Ant (http://ant.apache.org/)
   #
-  class StarTeam < AbstractSCM
-    register self
+  class StarTeam < Base
+    #register self
 
     ann :description => "User name"
     attr_accessor :user_name
@@ -49,23 +49,23 @@ module RSCM
       "StarTeam"
     end
     
-    def changesets(checkout_dir, from_identifier=Time.epoch, to_identifier=Time.infinity, &proc)
+    def revisions(checkout_dir, from_identifier=Time.epoch, to_identifier=Time.infinity, &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)
+      revisions = java("getRevisions(\"#{from}\";\"#{to}\")", &proc)
+      raise "revisions must be of type #{Revisions.name} - was #{revisions.class.name}" unless revisions.is_a?(::RSCM::Revisions)
 
       # Just a little sanity check
-      if(changesets.latest)
-        latetime = changesets.latest.time
+      if(revisions.latest)
+        latetime = revisions.latest.time
         if(latetime < from_identifier || to_identifier < latetime)
           raise "Latest time (#{latetime}) is not within #{from_identifier}-#{to_identifier}"
         end
       end
-      changesets
+      revisions
     end
 
     def checkout(checkout_dir, to_identifier, &proc)

data/lib/rscm/scm/subversion.rb

@@ -1,4 +1,4 @@
-require 'rscm/abstract_scm'
+require 'rscm/base'
 require 'rscm/path_converter'
 require 'rscm/line_editor'
 require 'rscm/scm/subversion_log_parser'
@@ -10,22 +10,29 @@ module RSCM
   # 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 Subversion < AbstractSCM
+  class Subversion < Base
     register self
 
     include FileUtils
     include PathConverter
     
     ann :description => "Repository URL"
-#    ann :tip => "If you specify a local URL (starting with file://) DamageControl can create the repository for you after you save (unless the repository already exists).<br>Using a file:// URL will also give you the option to have DamageControl install a trigger in Subversion, so that you don't have to use polling to detect changes.<br>On Windows, file URLs must look like file:///C:/jupiter/mars"
     ann :tip => "If you use ssh, specify the URL as svn+ssh://username@server/path/to/repo"
     attr_accessor :url
 
+    ann :description => "Username"
+    ann :tip => "This only applies to svn:// URLs."
+    attr_accessor :username
+
+    ann :description => "Password"
+    ann :tip => "This only applies to svn:// URLs."
+    attr_accessor :password
+
     ann :description => "Path"
-    ann :tip => "This is the relative path from the start of the repository <br>to the end of the URL. For example, if your URL is <br>svn://your.server/path/to/repository/path/within/repository <br>then this value should be path/within/repository."
+    ann :tip => "You only need to specify this if you want to be able to automatically create the repository. This should be the relative path from the start of the repository <br>to the end of the URL. For example, if your URL is <br>svn://your.server/path/to/repository/path/within/repository <br>then this value should be path/within/repository."
     attr_accessor :path
 
-    def initialize(url="", path="trunk")
+    def initialize(url="", path="")
       @url, @path = url, path
     end
 
@@ -33,21 +40,21 @@ module RSCM
       "Subversion"
     end
 
-    def add(checkout_dir, relative_filename)
-      svn(checkout_dir, "add #{relative_filename}")
+    def add(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)
+    def checkout(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(checked_out?)
+        svn(@checkout_dir, update_command(to_identifier)) do |line|
           if(line =~ path_regex)
             absolute_path = "#{checkout_dir}/#{$1}"
             relative_path = $1.chomp
@@ -57,14 +64,15 @@ module RSCM
           end
         end
       else
-        svn(checkout_dir, checkout_command(checkout_dir, to_identifier)) do |line|
+        svn(@checkout_dir, checkout_command(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)
+            absolute_path = PathConverter.nativepath_to_filepath(native_absolute_path)
             if(File.exist?(absolute_path) && !File.directory?(absolute_path))
-              relative_path = native_absolute_path[native_checkout_dir.length+1..-1].chomp
+              native_checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
+#              relative_path = native_absolute_path[native_checkout_dir.length+1..-1].chomp
+# not sure about this old code - this seems to work. keep it here till it's verified on win32
+              relative_path = absolute_path
               relative_path = relative_path.gsub(/\\/, "/") if WINDOWS
               checked_out_files << relative_path
               yield relative_path if block_given?
@@ -83,60 +91,43 @@ module RSCM
       "svn update #{url} #{checkout_dir}"
     end
 
-    def uptodate?(checkout_dir, from_identifier)
-      if(!checked_out?(checkout_dir))
+    def uptodate?(identifier)
+      if(!checked_out?)
         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
+        rev = identifier ? identifier : head_revision_identifier
+        local_revision_identifier == rev
       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 = SubversionLogParser.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))
+    def commit(message)
+      svn(@checkout_dir, commit_command(message))
       # We have to do an update to get the local revision right
-      svn(checkout_dir, "update")
+      svn(@checkout_dir, "update")
     end
 
-    def label(checkout_dir)
-      local_revision(checkout_dir).to_s
+    def label
+      local_revision_identifier.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|
+    def diff(file, &block)
+      with_working_dir(@checkout_dir) do
+        cmd = "svn diff -r #{file.previous_native_revision_identifier}:#{file.native_revision_identifier} \"#{url}/#{file.path}\""
+        Better.popen(cmd) do |io|
           return(yield(io))
         end
       end
     end
 
-    def can_create?
+    def can_create_central?
       local?
     end
 
-    def exists?
+    def destroy_central
+      FileUtils.rm_rf(svnrootdir)
+    end
+
+    def central_exists?
       if(local?)
         File.exists?("#{svnrootdir}/db")
       else
@@ -145,7 +136,7 @@ module RSCM
         # on stdout (and an error msg on std err).
         exists = false
         cmd = "svn log #{url} -r HEAD"
-        IO.popen(cmd) do |stdout|
+        Better.popen(cmd) do |stdout|
           stdout.each_line do |line|
             exists = true
           end
@@ -158,7 +149,7 @@ module RSCM
       local?
     end
 
-    def create      
+    def create_central
       native_path = PathConverter.filepath_to_nativepath(svnrootdir, true)
       mkdir_p(PathConverter.nativepath_to_filepath(native_path))
       svnadmin(svnrootdir, "create #{native_path}")
@@ -182,27 +173,27 @@ module RSCM
       not_already_commented
     end
     
-    def import(dir, message)
+    def import_central(dir, message)
       import_cmd = "import #{url} -m \"#{message}\""
       svn(dir, import_cmd)
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
-      # 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)
+    def revisions(from_identifier, to_identifier=Time.infinity)
+      # Return empty revision if the requested revision doesn't exist yet.
+      return Revisions.new if(from_identifier.is_a?(Integer) && head_revision_identifier <= from_identifier)
 
-      checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
-      changesets = nil
+      checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
+      revisions = nil
       command = "svn #{changes_command(from_identifier, to_identifier)}"
       yield command if block_given?
 
-      with_working_dir(checkout_dir) do
-        safer_popen(command) do |stdout|
-          parser = SubversionLogParser.new(stdout, path, checkout_dir)
-          changesets = parser.parse_changesets
+      with_working_dir(@checkout_dir) do
+        Better.popen(command) do |stdout|
+          parser = SubversionLogParser.new(stdout, @url)
+          revisions = parser.parse_revisions
         end
       end
-      changesets
+      revisions
     end
     
     # url pointing to the root of the repo
@@ -211,7 +202,7 @@ module RSCM
       url[0..last]
     end
 
-    def checked_out?(checkout_dir)
+    def checked_out?
       rootentries = File.expand_path("#{checkout_dir}/.svn/entries")
       result = File.exists?(rootentries)
       result
@@ -219,6 +210,30 @@ module RSCM
 
   private
 
+    def local_revision_identifier
+      local_revision_identifier = nil
+      svn(@checkout_dir, "info") do |line|
+        if(line =~ /Revision: ([0-9]*)/)
+          return $1.to_i
+        end
+      end
+    end
+
+    def head_revision_identifier
+      # This command only seems to yield any changesets if the url is the root of
+      # the repo, which we don't know in the case where path is not specified (likely)
+      # We therefore don't specify it and get the latest revision from the full url instead.
+      # cmd = "svn log #{login_options} #{repourl} -r HEAD"
+      cmd = "svn log #{login_options} #{url}"
+      with_working_dir(@checkout_dir) do
+        Better.popen(cmd) do |stdout|
+          parser = SubversionLogParser.new(stdout, @url)
+          revisions = parser.parse_revisions
+          revisions[0].identifier.to_i
+        end
+      end
+    end
+
     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
@@ -227,7 +242,7 @@ module RSCM
           file.puts("#!/bin/sh") unless post_commit_exists 
           file.puts("#{trigger_command}\n" )
         end
-        system("chmod g+x #{post_commit_file}")
+        File.chmod(0744, 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" +
@@ -265,7 +280,7 @@ module RSCM
       command_line = "#{executable} #{cmd}"
       dir = File.expand_path(dir)
       with_working_dir(dir) do
-        safer_popen(command_line) do |stdout|
+        Better.popen(command_line) do |stdout|
           stdout.each_line do |line|
             yield line if block_given?
           end
@@ -273,36 +288,50 @@ module RSCM
       end
     end
     
-    def checkout_command(checkout_dir, to_identifier)
+    def checkout_command(to_identifier)
       checkout_dir = "\"#{checkout_dir}\""
-      "checkout #{url} #{checkout_dir} #{revision_option(nil,to_identifier)}"
+      "checkout #{login_options} #{url} #{checkout_dir} #{revision_option(nil,to_identifier)}"
     end
 
     def update_command(to_identifier)
-      "update #{revision_option(nil,to_identifier)}"
+      "update #{login_options} #{revision_option(nil,to_identifier)}"
     end
     
     def changes_command(from_identifier, to_identifier)
       # 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 = "log --verbose #{login_options} #{revision_option(from_identifier, to_identifier)} #{url}"
       cmd
     end
 
+    def login_options
+      result = ""
+      u = @username ? @username.strip : nil
+      p = @password ? @password.strip : nil
+      result << "--username #{u} " if u
+      result << "--password #{p} " if p
+      result
+    end
+
     def revision_option(from_identifier, to_identifier)
+      # The inclusive start
       from = nil
       if(from_identifier.is_a?(Time))
-        from = svndate(from_identifier)
-      else
-        from = from_identifier
+        from = svndate(from_identifier + 1)
+      elsif(from_identifier.is_a?(Numeric))
+        from = from_identifier + 1
+      elsif(!from_identifier.nil?)
+        raise "from_identifier must be Numeric, Time or nil. Was: #{from_identifier} (#{from_identifier.class.name})"
       end
 
       to = nil
       if(to_identifier.is_a?(Time))
         to = svndate(to_identifier)
-      else
+      elsif(to_identifier.is_a?(Numeric))
         to = to_identifier
+      elsif(!from_identifier.nil?)
+        raise "to_identifier must be Numeric, Time or nil. Was: #{to_identifier} (#{to_identifier.class.name})"
       end
 
       revision_option = nil

data/lib/rscm/scm/subversion_log_parser.rb

@@ -1,108 +1,137 @@
 require 'rscm/parser'
-require 'rscm/changes'
+require 'rscm/revision'
 
 module RSCM
 
   class SubversionLogParser
-    def initialize(io, path, checkout_dir)
+    def initialize(io, url)
       @io = io
-      @changeset_parser = SubversionLogEntryParser.new(path, checkout_dir)
+      @revision_parser = SubversionLogEntryParser.new(url)
     end
     
-    def parse_changesets(&line_proc)
+    def parse_revisions(&line_proc)
       # skip over the first ------
-      @changeset_parser.parse(@io, true, &line_proc)
-      changesets = ChangeSets.new
+      @revision_parser.parse(@io, true, &line_proc)
+      revisions = Revisions.new
       while(!@io.eof?)
-        changeset = @changeset_parser.parse(@io, &line_proc)
-        if(changeset)
-          changesets.add(changeset)
+        revision = @revision_parser.parse(@io, &line_proc)
+        if(revision)
+          revisions.add(revision)
         end
       end
-      changesets
+      revisions
     end
   end
   
   class SubversionLogEntryParser < Parser
 
-    def initialize(path, checkout_dir)
+    def initialize(url)
       super(/^------------------------------------------------------------------------/)
-      @path = path ? path : ""
-      @checkout_dir = checkout_dir
+      @url = url
     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
+      revision = super
+      revision.message = revision.message[0..-2] if revision
+      revision
     end
 
+    def relative_path(url, repo_path)
+      url_tokens = url.split('/')
+      repo_path_tokens = repo_path.split('/')
+      
+      max_similar = repo_path_tokens.length
+      while(max_similar > 0)
+        url = url_tokens[-max_similar..-1]
+        path = repo_path_tokens[0..max_similar-1]
+        if(url == path)
+          break
+        end
+        max_similar -= 1
+      end
+      max_similar == 0 ? nil : repo_path_tokens[max_similar..-1].join("/")
+    end
+    
   protected
 
     def parse_line(line)
-      if(@changeset.nil?)
+      if(@revision.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 or if changesets are computed before checkout (which it usually is!)
-          fullpath = "#{@checkout_dir}/#{change.path}"
-          @changeset << change unless File.directory?(fullpath)
+        @parse_state = :parse_files
+      elsif(@parse_state == :parse_files)
+        file = parse_file(line)
+        if(file)
+          previously_added_file = @revision[-1]
+          if(previously_added_file)
+            # remove previous revision_file it if it's a dir
+            previous_tokens = previously_added_file.path.split("/")
+            current_tokens = file.path.split("/")
+            current_tokens.pop
+            if(previous_tokens == current_tokens)
+              @revision.pop
+            end
+          end
+          @revision << file
         end
       elsif(@parse_state == :parse_message)
-        @changeset.message << line.chomp << "\n"
+        @revision.message << line.chomp << "\n"
       end
     end
 
     def next_result
-      result = @changeset
-      @changeset = nil
+      result = @revision
+      @revision = nil
       result
     end
 
   private
   
-    STATES = {"M" => Change::MODIFIED, "A" => Change::ADDED, "D" => Change::DELETED} unless defined? STATES
+    STATES = {"M" => RevisionFile::MODIFIED, "A" => RevisionFile::ADDED, "D" => RevisionFile::DELETED} unless defined? STATES
 
     def parse_header(line)
-      @changeset = ChangeSet.new
-      @changeset.message = ""
+      @revision = Revision.new
+      @revision.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?
+      @revision.identifier = revision.strip[1..-1].to_i unless revision.nil?
+      @revision.developer = developer.strip unless developer.nil?
+      @revision.time = parse_time(time.strip) unless time.nil?
     end
     
-    def parse_change(line)
-      change = Change.new
+    def parse_file(line)
+      file = RevisionFile.new
       path_from_root = nil
       if(line =~ /^   [M|A|D|R] ([^\s]+) \(from (.*)\)/)
         path_from_root = $1
-        change.status = Change::MOVED
+        file.status = RevisionFile::MOVED
       elsif(line =~ /^   ([M|A|D|R]) (.+)$/)
         status = $1
         path_from_root = $2
-        change.status = STATES[status]
+        file.status = STATES[status]
       else
-        raise "could not parse change line: '#{line}'"
+        raise "could not parse file 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
+      path_from_root = path_from_root[1..-1]
+      rp = relative_path(@url, path_from_root)
+      return if rp.nil?
+      file.path = rp
+
+      
+#      if(@path.length+1 == path_from_root.length)
+#        file.path = path_from_root[@path.length+1..-1]
+#      else
+#        file.path = path_from_root[@path.length+2..-1]
+#      end
+
+      file.native_revision_identifier =  @revision.identifier
       # http://jira.codehaus.org/browse/DC-204
-      change.previous_revision = change.revision.to_i - 1;
-      change
+      file.previous_native_revision_identifier = file.native_revision_identifier.to_i - 1;
+      file
     end
 
     def parse_time(svn_time)