rscm 0.2.1.1404 → 0.3.0

data/lib/rscm/better.rb

@@ -0,0 +1,16 @@
+module RSCM
+  class Better
+    @@logger = nil
+    @@logger = RSCM_DEFAULT_LOGGER
+    
+    def self.popen(cmd, mode="r", expected_exit=0, &proc)
+      @@logger.info "Executing command: '#{cmd}'" if @@logger
+      ret = IO.popen(cmd, mode) do |io|
+        proc.call(io)
+      end
+      exit_code = $? >> 8
+      raise "Command\n'#{cmd}'\nfailed with code #{exit_code} in\n#{Dir.pwd}\nExpected exit code: #{expected_exit}" if exit_code != expected_exit
+      ret
+    end
+  end
+end

data/lib/rscm/logging.rb

@@ -1,6 +1,12 @@
-require 'rubygems'
-require_gem 'log4r'
+require 'logger'
 
-Log = Log4r::Logger.new("rscm")
-Log.level = ENV["LOG4R_LEVEL"] ? ENV["LOG4R_LEVEL"].to_i : 0
-Log.add Log4r::Outputter.stderr
+begin
+  RSCM_DEFAULT_LOGGER = Logger.new("#{HOMEDIR}/.rscm.log")
+rescue StandardError
+  RSCM_DEFAULT_LOGGER = Logger.new(STDERR)
+  RSCM_DEFAULT_LOGGER.level = Logger::WARN
+  RSCM_DEFAULT_LOGGER.warn(
+    "RSCM Error: Unable to access log file. Please ensure that #{HOMEDIR}/.rscm.log exists and is chmod 0666. " +
+    "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+  )
+end

data/lib/rscm/path_converter.rb

@@ -1,20 +1,15 @@
-require 'fileutils'
-require 'rscm/logging'
-
 WIN32 = RUBY_PLATFORM == "i386-mswin32"
 CYGWIN = RUBY_PLATFORM == "i386-cygwin"
 WINDOWS = WIN32 || CYGWIN
-
-# TODO: change to override IO.popen, using that neat trick we
-# used in threadfile.rb (which is now gone)
-def safer_popen(cmd, mode="r", expected_exit=0, &proc)
-  Log.info "Executing command: '#{cmd}'"
-  ret = IO.popen(cmd, mode, &proc)
-  exit_code = $? >> 8
-  raise "#{cmd} failed with code #{exit_code} in #{Dir.pwd}. Expected exit code: #{expected_exit}" if exit_code != expected_exit
-  ret
+if(WINDOWS)
+  HOMEDIR = RSCM::PathConverter.nativepath_to_filepath("#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}").gsub(/\\/, "/")
+else
+  HOMEDIR = ENV['HOME']
 end
 
+require 'fileutils'
+require 'rscm/logging'
+
 def with_working_dir(dir)
   # Can't use Dir.chdir{ block } - will fail with multithreaded code.
   # http://www.ruby-doc.org/core/classes/Dir.html#M000790
@@ -22,10 +17,8 @@ def with_working_dir(dir)
   prev = Dir.pwd
   begin
     dir = File.expand_path(dir)
-    Log.info "Making directory: '#{dir}'"
     FileUtils.mkdir_p(dir)
     Dir.chdir(dir)
-    Log.info "In directory: '#{dir}'"
     yield
   ensure
     Dir.chdir(prev)
@@ -42,7 +35,7 @@ module RSCM
         path.gsub(/\//, "\\")
       elsif(CYGWIN)
         cmd = "cygpath --windows #{path}"
-        safer_popen(cmd) do |io|
+        Better.popen(cmd) do |io|
           cygpath = io.read.chomp
           escaped ? cygpath.gsub(/\\/, "\\\\\\\\") : cygpath
         end
@@ -68,7 +61,7 @@ module RSCM
       elsif(CYGWIN)
         path = path.gsub(/\\/, "/")
         cmd = "cygpath --unix #{path}"
-        safer_popen(cmd) do |io|
+        Better.popen(cmd) do |io|
           io.read.chomp
         end
       else

data/lib/rscm/revision.rb

@@ -0,0 +1,201 @@
+require 'xmlrpc/utils'
+require 'rscm/time_ext'
+require 'rscm/revision_file'
+
+module RSCM
+
+  # A collection of Revision.
+  class Revisions
+    include Enumerable
+    include XMLRPC::Marshallable
+
+    attr_accessor :revisions
+
+    def initialize(revisions=[])
+      @revisions = revisions
+    end
+    
+    # Accepts a visitor that will receive callbacks while
+    # iterating over this instance's internal structure.
+    # The visitor should respond to the following methods:
+    #
+    # * visit_revisions(revisions)
+    # * visit_revision(revision)
+    # * visit_file(file)
+    #
+    def accept(visitor)
+      visitor.visit_revisions(self)
+      self.each{|revision| revision.accept(visitor)}
+    end
+
+    def [](file)
+      @revisions[file]
+    end
+
+    def each(&block)
+      @revisions.each(&block)
+    end
+    
+    def reverse
+      r = clone
+      r.revisions = @revisions.dup.reverse
+      r
+    end
+    
+    def length
+      @revisions.length
+    end
+
+    def ==(other)
+      return false if !other.is_a?(self.class)
+      @revisions == other.revisions
+    end
+    
+    def empty?
+      @revisions.empty?
+    end
+    
+    # The set of developers that contributed to all of the contained Revision s.
+    def developers
+      result = []
+      each do |revision|
+        result << revision.developer unless result.index(revision.developer)
+      end
+      result
+    end
+    
+    # The latest Revision (with the latest time)
+    # or nil if there are none.
+    def latest
+      result = nil
+      each do |revision|
+        result = revision if result.nil? || result.time < revision.time
+      end
+      result
+    end
+
+    # Adds a File or a Revision.
+    # If the argument is a File and no corresponding Revision exists,
+    # a new Revision is created, added, and the File is added to that Revision -
+    # and then finally the newly created Revision is returned.
+    # Otherwise nil is returned.
+    def add(file_or_revision)
+      if(file_or_revision.is_a?(Revision))
+        @revisions << file_or_revision
+        return file_or_revision
+      else
+        revision = @revisions.find { |a_revision| a_revision.can_contain?(file_or_revision) }
+        if(revision.nil?)
+          revision = Revision.new
+          @revisions << revision
+          revision << file_or_revision
+          return revision
+        end
+        revision << file_or_revision
+        return nil
+      end
+    end
+    
+    def push(*file_or_revisions)
+      file_or_revisions.each { |file_or_revision| self << (file_or_revision) }
+      self
+    end
+
+    # Sorts the revisions according to time
+    def sort!
+      @revisions.sort!
+      self
+    end
+
+  end
+
+  # Represents a collection of File that were committed at the same time.
+  # Non-transactional SCMs (such as CVS and StarTeam) emulate Revision
+  # by grouping File s that were committed by the same developer, with the
+  # same commit message, and within a "reasonably" small timespan.
+  class Revision
+    include Enumerable
+    include XMLRPC::Marshallable
+
+    attr_reader :files
+    attr_accessor :identifier
+    attr_accessor :developer
+    attr_accessor :message
+    attr_accessor :time
+
+    def initialize(files=[])
+      @files = files
+    end
+    
+    def accept(visitor)
+      visitor.visit_revision(self)
+      @files.each{|file| file.accept(visitor)}
+    end
+
+    def << (file)
+      @files << file
+      if(self.time.nil? || self.time < file.time unless file.time.nil?)
+        self.time = file.time
+        self.identifier = self.time if(self.identifier.nil? || self.identifier.is_a?(Time))
+      end
+      self.developer = file.developer if file.developer
+      self.message = file.message if file.message
+    end
+
+    def [] (file)
+      @files[file]
+    end
+
+    def each(&block)
+      @files.each(&block)
+    end
+    
+    def pop
+      @files.pop
+    end
+    
+    def length
+      @files.length
+    end
+
+    def time=(t)
+      raise "time must be a Time object - it was a #{t.class.name} with the string value #{t}" unless t.is_a?(Time)
+      raise "can't set time to an inferiour value than the previous value" if @time && (t < @time)
+      @time = t
+    end
+    
+    def ==(other)
+      return false if !other.is_a?(self.class)
+      @files == other.files
+    end
+
+    def <=>(other)
+      @time <=> other.time
+    end
+
+    # Whether this instance can contain a File. Used
+    # by non-transactional SCMs.
+    def can_contain?(file)
+      self.developer == file.developer &&
+      self.message == file.message &&
+      (self.time - file.time).abs < 60
+    end
+
+    # String representation that can be used for debugging.
+    def to_s
+      result = "#{identifier} | #{developer} | #{time} | #{message}\n"
+      self.each do |file|
+        result << " " << file.to_s << "\n"
+      end
+      result
+    end
+    
+    # Returns the identifier of the revision. This is the revision 
+    # (if defined) or an UTC time if it is not natively supported by the scm.
+    def identifierAA
+      @identifier || @time
+    end
+    
+  end
+
+end

data/lib/rscm/revision_file.rb

@@ -0,0 +1,71 @@
+module RSCM
+  # Represents a file within a Revision, and also information about how this file
+  # was modified compared with the previous revision.
+  class RevisionFile
+    include XMLRPC::Marshallable
+
+    MODIFIED = "MODIFIED"
+    DELETED = "DELETED"
+    ADDED = "ADDED"
+    MOVED = "MOVED"
+    
+    attr_accessor :status
+    attr_accessor :path
+    attr_accessor :previous_native_revision_identifier
+    # The native SCM's revision for this file. For non-transactional SCMs this is different from
+    # the parent Revision's 
+    attr_accessor :native_revision_identifier
+
+    attr_accessor :developer
+    attr_accessor :message
+    # This is a UTC ruby time
+    attr_accessor :time
+    
+    def initialize(path=nil, status=nil, developer=nil, message=nil, native_revision_identifier=nil, time=nil)
+      @path, @developer, @message, @native_revision_identifier, @time, @status = path, developer, message, native_revision_identifier, time, status
+    end
+  
+    def accept(visitor)
+      visitor.visit_file(self)
+    end
+
+    def to_s
+      "#{path} | #{native_revision_identifier}"
+    end
+
+    def developer=(developer)
+      raise "can't be null" if developer.nil?
+      @developer = developer
+    end
+    
+    def message=(message)
+      raise "can't be null" if message.nil?
+      @message = message
+    end
+
+    def path=(path)
+      raise "can't be null" if path.nil?
+      @path = path
+    end
+
+    def native_revision_identifier=(id)
+      raise "can't be null" if id.nil?
+      @native_revision_identifier = id
+    end
+
+    def time=(time)
+      raise "time must be a Time object" unless time.is_a?(Time)
+      @time = time
+    end
+
+    def ==(other)
+      return false if !other.is_a?(self.class)
+      self.path == other.path &&
+      self.developer == other.developer &&
+      self.message == other.message &&
+      self.native_revision_identifier == other.native_revision_identifier &&
+      self.time == other.time
+    end
+    
+  end
+end

data/lib/rscm/scm/clearcase.rb

@@ -1,9 +1,9 @@
-require 'rscm/abstract_scm'
+require 'rscm/base'
 require 'rscm/path_converter'
 require 'fileutils'
 
 module RSCM
-  class ClearCase < AbstractSCM
+  class ClearCase < Base
   
     LOG_FORMAT = "Developer:%u\\nTime:%Nd\\nExtendedName:%Xn\\nVersionId:%Vn\\nPreviousVersionId:%PVn\\nElementName:%En\\nOID:%On\\nO:%o\\nMessage:%Nc\\n------------------------------------------\\n"
   
@@ -11,13 +11,13 @@ module RSCM
       "ClearCase"
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
-      result = ChangeSets.new
+    def revisions(checkout_dir, from_identifier, to_identifier=Time.infinity)
+      result = Revisions.new
       with_working_dir(checkout_dir) do
         since = from_identifier.strftime("%d-%b-%Y.%H:%M:%S")
         cleartool("lshistory -recurse -nco -since #{since} -fmt #{LOG_FORMAT}") do |io|
           io.each_line {|l| puts l}
-          changesets << ChangeSet.new()
+          revisions << Revision.new()
         end
       end
       result
@@ -25,7 +25,7 @@ module RSCM
     
     def diff(checkout_dir, change)
       with_working_dir(checkout_dir) do
-        cleartool("diff -diff_format #{change.path}@@#{change.previous_revision} #{change.path}@@#{change.revision}")
+        cleartool("diff -diff_format #{change.path}@@#{change.previous_native_revision_identifier} #{change.path}@@#{change.revision}")
       end
     end
 
@@ -71,7 +71,7 @@ module RSCM
   
     def cleartool(cleartool_cmd)
       cmd = "cleartool #{cleartool_cmd}"
-      safer_popen(cmd, "r+") do |io|
+      Better.popen(cmd, "r+") do |io|
         if(block_given?)
           return(yield(io))
         else

data/lib/rscm/scm/cvs.rb

@@ -1,4 +1,4 @@
-require 'rscm/abstract_scm'
+require 'rscm/base'
 require 'rscm/path_converter'
 require 'rscm/line_editor'
 require 'rscm/scm/cvs_log_parser'
@@ -10,7 +10,7 @@ module RSCM
   # You need a cvs executable on the PATH in order for it to work.
   #
   # NOTE: On Cygwin this has to be the win32 build of cvs and not the Cygwin one.
-  class Cvs < AbstractSCM
+  class Cvs < Base
     register self
 
     ann :description => "CVSROOT"
@@ -33,22 +33,22 @@ module RSCM
       "CVS"
     end
     
-    def import(dir, message)
+    def import_central(dir, message)
       modname = File.basename(dir)
       cvs(dir, "import -m \"#{message}\" #{modname} VENDOR START")
     end
     
-    def add(checkout_dir, relative_filename)
-      cvs(checkout_dir, "add #{relative_filename}")
+    def add(relative_filename)
+      cvs(@checkout_dir, "add #{relative_filename}")
     end
 
     # The extra simulate parameter is not in accordance with the AbstractSCM API,
     # but it's optional and is only being used from within this class (uptodate? method).
-    def checkout(checkout_dir, to_identifier=nil, simulate=false)
+    def checkout(to_identifier=nil, simulate=false)
       checked_out_files = []
-      if(checked_out?(checkout_dir))
+      if(checked_out?)
         path_regex = /^[U|P] (.*)/
-        cvs(checkout_dir, update_command(to_identifier), simulate) do |line|
+        cvs(@checkout_dir, update_command(to_identifier), simulate) do |line|
           if(line =~ path_regex)
             path = $1.chomp
             yield path if block_given?
@@ -56,12 +56,12 @@ module RSCM
           end
         end
       else
-        prefix = File.basename(checkout_dir)
+        prefix = File.basename(@checkout_dir)
         path_regex = /^[U|P] #{prefix}\/(.*)/
         # This is a workaround for the fact that -d . doesn't work - must be an existing sub folder.
-        mkdir_p(checkout_dir) unless File.exist?(checkout_dir)
-        target_dir = File.basename(checkout_dir)
-        run_checkout_command_dir = File.dirname(checkout_dir)
+        mkdir_p(@checkout_dir) unless File.exist?(@checkout_dir)
+        target_dir = File.basename(@checkout_dir)
+        run_checkout_command_dir = File.dirname(@checkout_dir)
         # -D is sticky, but subsequent updates will reset stickiness with -A
         cvs(run_checkout_command_dir, checkout_command(target_dir, to_identifier), simulate) do |line|
           if(line =~ path_regex)
@@ -74,65 +74,57 @@ module RSCM
       checked_out_files
     end
     
-    def checkout_commandline(to_identifier=Time.infinity)
-      "cvs checkout #{branch_option} #{revision_option(to_identifier)} #{mod}"
+    def commit(message, &proc)
+      cvs(@checkout_dir, commit_command(message), &proc)
     end
 
-    def update_commandline
-      "cvs update #{branch_option} -d -P -A"
-    end
-
-    def commit(checkout_dir, message, &proc)
-      cvs(checkout_dir, commit_command(message), &proc)
-    end
-
-    def uptodate?(checkout_dir, since)
-      if(!checked_out?(checkout_dir))
+    def uptodate?(identifier)
+      if(!checked_out?)
         return false
       end
 
       # simulate a checkout
-      files = checkout(checkout_dir, nil, true)
+      files = checkout(identifier, true)
       files.empty?
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
-      checkout(checkout_dir) unless uptodate?(checkout_dir, nil) # must checkout to get changesets
-      parse_log(checkout_dir, changes_command(from_identifier, to_identifier))
+    def revisions(from_identifier, to_identifier=Time.infinity)
+      checkout(to_identifier) unless uptodate?(to_identifier) # must checkout to get revisions
+      parse_log(changes_command(from_identifier, to_identifier))
     end
     
-    def diff(checkout_dir, change)
-      with_working_dir(checkout_dir) do
+    def diff(change)
+      with_working_dir(@checkout_dir) do
         opts = case change.status
-          when /#{Change::MODIFIED}/; "#{revision_option(change.previous_revision)} #{revision_option(change.revision)}"
-          when /#{Change::DELETED}/; "#{revision_option(change.previous_revision)}"
-          when /#{Change::ADDED}/; "#{revision_option(Time.epoch)} #{revision_option(change.revision)}"
+          when /#{RevisionFile::MODIFIED}/; "#{revision_option(change.previous_native_revision_identifier)} #{revision_option(change.native_revision_identifier)}"
+          when /#{RevisionFile::DELETED}/; "#{revision_option(change.previous_native_revision_identifier)}"
+          when /#{RevisionFile::ADDED}/; "#{revision_option(Time.epoch)} #{revision_option(change.native_revision_identifier)}"
         end
         # IMPORTANT! CVS NT has a bug in the -N diff option
         # http://www.cvsnt.org/pipermail/cvsnt-bugs/2004-November/000786.html
         cmd = command_line("diff -Nu #{opts} #{change.path}")
-        safer_popen(cmd, "r", 1) do |io|
+        Better.popen(cmd, "r", 1) do |io|
           return(yield(io))
         end
       end
     end
     
-    def apply_label(checkout_dir, label)
-      cvs(checkout_dir, "tag -c #{label}")
+    def apply_label(label)
+      cvs(@checkout_dir, "tag -c #{label}")
     end
     
     def install_trigger(trigger_command, trigger_files_checkout_dir)
       raise "mod can't be null or empty" if (mod.nil? || mod == "")
 
-      root_cvs = create_root_cvs
-      root_cvs.checkout(trigger_files_checkout_dir)
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
+      root_cvs.checkout
       with_working_dir(trigger_files_checkout_dir) do
         trigger_line = "#{mod} #{trigger_command}\n"
         File.open("loginfo", File::WRONLY | File::APPEND) do |file|
           file.puts(trigger_line)
         end
         begin
-          commit(trigger_files_checkout_dir, "Installed trigger for CVS module '#{mod}'")
+          root_cvs.commit("Installed trigger for CVS module '#{mod}'")
         rescue
           raise "Couldn't commit the trigger back to CVS. Try to manually check out CVSROOT/loginfo, " +
           "add the following line and commit it back:\n\n#{trigger_line}"
@@ -144,9 +136,9 @@ module RSCM
       loginfo_line = "#{mod} #{trigger_command}"
       regex = Regexp.new(Regexp.escape(loginfo_line))
 
-      root_cvs = create_root_cvs
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
       begin
-        root_cvs.checkout(trigger_files_checkout_dir)
+        root_cvs.checkout
         loginfo = File.join(trigger_files_checkout_dir, "loginfo")
         return false if !File.exist?(loginfo)
 
@@ -168,23 +160,36 @@ module RSCM
       loginfo_line = "#{mod} #{trigger_command}"
       regex = Regexp.new(Regexp.escape(loginfo_line))
 
-      root_cvs = create_root_cvs
-      root_cvs.checkout(trigger_files_checkout_dir)
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
+      root_cvs.checkout
       loginfo_path = File.join(trigger_files_checkout_dir, "loginfo")
       File.comment_out(loginfo_path, regex, "# ")
       with_working_dir(trigger_files_checkout_dir) do
-        commit(trigger_files_checkout_dir, "Uninstalled trigger for CVS mod '#{mod}'")
+        root_cvs.commit("Uninstalled trigger for CVS mod '#{mod}'")
       end
       raise "Couldn't uninstall/commit trigger to loginfo" if trigger_installed?(trigger_command, trigger_files_checkout_dir)
     end
 
-    def create
-      raise "Can't create CVS repository for #{root}" unless can_create?
+    def create_central
+      raise "Can't create central CVS repository for #{root}" unless can_create_central?
       File.mkpath(path)
       cvs(path, "init")
     end
+
+    def destroy_central
+      FileUtils.rm_rf(path)
+    end
     
-    def can_create?
+    def central_exists?
+      if(local?)
+        File.exists?("#{path}/CVSROOT/loginfo")
+      else
+        # don't know. assume yes.
+        true
+      end
+    end
+
+    def can_create_central?
       begin
         local?
       rescue
@@ -196,16 +201,7 @@ module RSCM
       true
     end
 
-    def exists?
-      if(local?)
-        File.exists?("#{path}/CVSROOT/loginfo")
-      else
-        # don't know. assume yes.
-        true
-      end
-    end
-
-    def checked_out?(checkout_dir)
+    def checked_out?
       rootcvs = File.expand_path("#{checkout_dir}/CVS/Root")
       File.exists?(rootcvs)
     end
@@ -217,7 +213,7 @@ module RSCM
       dir = File.expand_path(dir)
       execed_command_line = command_line(cmd, password, simulate)
       with_working_dir(dir) do
-        safer_popen(execed_command_line) do |stdout|
+        Better.popen(execed_command_line) do |stdout|
           stdout.each_line do |progress|
             yield progress if block_given?
           end
@@ -225,26 +221,26 @@ module RSCM
       end
     end
 
-    def parse_log(checkout_dir, cmd, &proc)
+    def parse_log(cmd, &proc)
       logged_command_line = command_line(cmd, hidden_password)
       yield logged_command_line if block_given?
 
       execed_command_line = command_line(cmd, password)
-      changesets = nil
-      with_working_dir(checkout_dir) do
-        safer_popen(execed_command_line) do |stdout|
+      revisions = nil
+      with_working_dir(@checkout_dir) do
+        Better.popen(execed_command_line) do |stdout|
           parser = CvsLogParser.new(stdout)
           parser.cvspath = path
           parser.cvsmodule = mod
-          changesets = parser.parse_changesets
+          revisions = parser.parse_revisions
         end
       end
-      changesets
+      revisions
     end
 
     def changes_command(from_identifier, to_identifier)
       # https://www.cvshome.org/docs/manual/cvs-1.11.17/cvs_16.html#SEC144
-      # -N => Suppress the header if no revisions are selected.
+      # -N => Suppress the header if no RevisionFiles are selected.
       "log #{branch_option} -N #{period_option(from_identifier, to_identifier)}"
     end
 
@@ -261,7 +257,7 @@ module RSCM
     end
 
     def checkout_command(target_dir, to_identifier)
-      "checkout #{branch_option} -d #{target_dir} #{mod} #{revision_option(to_identifier)}"
+      "checkout #{branch_option} -d #{target_dir} #{revision_option(to_identifier)} #{mod}"
     end
     
     def hidden_password
@@ -276,7 +272,7 @@ module RSCM
       if(from_identifier.nil? && to_identifier.nil?)
         ""
       else
-        "-d\"#{cvsdate(from_identifier)}<=#{cvsdate(to_identifier)}\" " 
+        "-d\"#{cvsdate(from_identifier)}<#{cvsdate(to_identifier)}\" " 
       end
     end
       
@@ -300,11 +296,14 @@ module RSCM
   
     def command_line(cmd, password=nil, simulate=false)
       cvs_options = simulate ? "-n" : ""
-      "cvs -f \"-d#{root_with_password(password)}\" #{cvs_options} -q #{cmd}"
+      dev_null = WIN32 ? "nul" : "/dev/null"
+      "cvs -f \"-d#{root_with_password(password)}\" #{cvs_options} -q #{cmd} 2> #{dev_null}"
     end
 
-    def create_root_cvs
-      Cvs.new(self.root, "CVSROOT", nil, self.password)
+    def create_root_cvs(checkout_dir)
+      cvs = Cvs.new(self.root, "CVSROOT", nil, self.password)
+      cvs.checkout_dir = checkout_dir
+      cvs
     end
 
     def revision_option(identifier)