rscm 0.4.5 → 0.5.0

data/lib/rscm/revision_file.rb

@@ -47,12 +47,18 @@ module RSCM
     # Returns/yields an IO containing the contents of this file, using the +scm+ this
     # file lives in.
     def open(scm, options={}, &block) #:yield: io
-      scm.open(self, options, &block)
+      scm.open(path, native_revision_identifier, options, &block)
     end
     
     # Yields the diff as an IO for this file
     def diff(scm, options={}, &block)
-      scm.diff(self, options, &block)
+      from_to = case status
+        when /#{RevisionFile::MODIFIED}/; [previous_native_revision_identifier, native_revision_identifier]
+        when /#{RevisionFile::DELETED}/; [previous_native_revision_identifier, nil]
+        when /#{RevisionFile::ADDED}/; [nil, native_revision_identifier]
+      end
+
+      scm.diff(path, from_to[0], from_to[1], options, &block)
     end
   
     # Accepts a visitor that must respond to +visit_file(revision_file)+ 

data/lib/rscm/revision_poller.rb

@@ -1,82 +1,93 @@
 module RSCM
-  class Base
+  module RevisionPoller
     attr_accessor :logger
   
-    TWO_WEEKS_AGO = 2*7*24*60*60
-    THIRTY_TWO_WEEKS_AGO = TWO_WEEKS_AGO * 16
-    # Default time to wait for scm to be quiet (applies to non-transactional scms only)
-    DEFAULT_QUIET_PERIOD = 15
+    # This is the number of revisions we'll try to stick to for each
+    # call to revisions.
+    CRITICAL_REVISION_SIZE = 100
+    BASE_INCREMENT = 60*60 # 1 hour
+    TWENTY_FOUR_HOURS = 24*60*60
     
-
-    # Polls new revisions for since +last_revision+,
-    # or if +last_revision+ is nil, polls since 'now' - +options[:seconds_before_now]+.
-    # If no revisions are found AND the poll was using +options[:seconds_before_now]+
-    # (i.e. it's the first poll, and no revisions were found),
-    # calls itself recursively with twice the +options[:seconds_before_now]+.
-    # This happens until revisions are found, ot until the +options[:seconds_before_now]+
-    # Exceeds 32 weeks, which means it's probably not worth looking further in
-    # the past, the scm is either completely idle or not yet active.
-    def poll_new_revisions(options)
-      options = {
-        :latest_revision => nil, 
-        :quiet_period => DEFAULT_QUIET_PERIOD, 
-        :seconds_before_now => TWO_WEEKS_AGO, 
-        :max_time_before_now => THIRTY_TWO_WEEKS_AGO,
-      }.merge(options)
-      max_past = Time.new.utc - options[:max_time_before_now]
-  
-      # Default value for start time (in case there are no detected revisions yet)
-      from = Time.new.utc - options[:seconds_before_now]
-      if(options[:latest_revision])
-        from = options[:latest_revision].identifier
+    # Polls revisions from +point+ and either backwards in time until the beginning 
+    # of time (Time.epoch) or forward in time until we're past +now+.
+    # 
+    # Whether to poll forwards or backwards in time depends on the value of +direction+.
+    #
+    # The +point+ argument can be either a Revision, String, Time or Fixnum representing 
+    # where to start from (upper boundary for backwards polling, lower boundary for
+    # forwards polling).
+    #
+    # The polling starts with a small interval from +point+ (1 hour) and increments (or decrements)
+    # gradually in order to try and keep the length of the yielded Revisions to about 100.
+    #
+    # The passed block will be called several times, each time with a Revisions object.
+    # In order to reduce the memory footprint and keep the performance decent, the length
+    # of each yielded Revisions object will usually be within the order of magnitude of 100.
+    # 
+    # TODO: handle non-transactional SCMs. There was some handling of this in older revisions
+    # of this file. We should dig it out and reenable it.
+    def poll(point=nil, direction=:backwards, multiplier=1, now=Time.now.utc, options={}, &proc)
+      raise "A block of arity 1 must be called" if proc.nil?
+      backwards = direction == :backwards      
+      point ||= now
+      
+      if point.respond_to?(:time)
+        point_time = backwards ? point.time(:min) : point.time(:max)
+        point_identifier = backwards ? point.identifier(:min) : point.identifier(:max)
+      elsif point.is_a?(Time)
+        point_time = point
+        point_identifier = point
       else
-        if(from < max_past)
-          logger.info "Checked for revisions as far back as #{max_past}. There were none, so we give up." if logger
-          return []
-        else
-          logger.info "Latest revision is not known. Checking for revisions since: #{from}" if logger
-        end
+        point_time = now
+        point_identifier = point
       end
 
-      logger.info "Polling revisions after #{from} (#{from.class.name})" if logger
-      
-      revisions = revisions(from, options)
-      if(revisions.empty?)
-        logger.info "No new revisions after #{from}" if logger
-        unless(options[:latest_revision])
-          double_seconds_before_now = 2*options[:seconds_before_now]
-          logger.info "Last revision still not found, checking since #{double_seconds_before_now.ago}" if logger
-          new_opts = options.dup
-          new_opts[:seconds_before_now] = double_seconds_before_now
-          return poll_new_revisions(new_opts)
+      increment = multiplier * BASE_INCREMENT
+      if backwards
+        to = point_identifier
+        begin
+          from = point_time - increment
+        rescue ArgumentError
+          from = Time.epoch
         end
+        from = Time.epoch if from < Time.epoch
       else
-        logger.info "There were #{revisions.length} new revision(s) after #{from}" if logger
+        from = point_identifier
+        begin
+          to = point_time + increment
+        rescue RangeError
+          raise "RSCM will not work this far in the future (#{from} plus #{increment})"
+        end
       end
 
-      if(!revisions.empty? && !transactional?)
-        # We're dealing with a non-transactional SCM (like CVS/StarTeam/ClearCase,
-        # unlike Subversion/Monotone). Sleep a little, get the revisions again.
-        # When the revisions 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 revisions for really slow commits, but they will be part of the next 
-        # revision (on next poll).
-        commit_in_progress = true
-        while(commit_in_progress)
-          logger.info "Sleeping for #{options[:quiet_period]} seconds because #{visual_name} is not transactional." if logger
-          
-          sleep(options[:quiet_period])
-          previous_revisions = revisions
-          revisions = revisions(from)
-          commit_in_progress = revisions != previous_revisions
-          if(commit_in_progress)
-            logger.info "Commit still in progress." if logger
-          end
-        end
-        logger.info "Quiet period elapsed" if logger
+      options = options.merge({:to_identifier => to})
+
+      revs = revisions(from, options)
+      raise "Got nil revision for from=#{from.inspect}" if revs.nil?
+      revs.sort!
+      proc.call(revs)
+
+      if from == Time.epoch
+        return
+      end
+      if !backwards and to.is_a?(Time) and (to) > now + TWENTY_FOUR_HOURS
+        return
+      end
+
+      if(revs.length < CRITICAL_REVISION_SIZE)
+        # We can do more
+        multiplier *= 2
       end
-      return revisions
+      if(revs.length > 2*CRITICAL_REVISION_SIZE)
+        # We must do less
+        multiplier /= 2
+      end
+
+      unless(revs.empty?)
+        point = backwards ? revs[0] : revs[-1]
+      end
+      poll(point, direction, multiplier, now, options, &proc)
     end
+    
   end
 end

data/lib/rscm/revisions.rb

@@ -0,0 +1,79 @@
+require 'rscm/time_ext'
+require 'rscm/revision_file'
+
+module RSCM
+
+  # A Revisions object is a collection of Revision objects with some
+  # additional behaviour.
+  #
+  # Most importantly, it provides logic to group individual RevisionFile
+  # objects into Revision objects internally. This means that implementors
+  # of RSCM adapters that don't support atomic changesets can still emulate 
+  # them, simply by adding RevisionFile objects to a Revisions object. Example:
+  #
+  #   revisions = Revisions.new
+  #   revisions.add revision_file_1
+  #   revisions.add revision_file_2
+  #   revisions.add revision_file_3
+  #
+  # The added RevisionFile objects will end up in Revision objects grouped by
+  # their comment, developer and timestamp. A set of RevisionFile object with
+  # identical developer and message will end up in the same Revision provided
+  # their <tt>time</tt> attributes are a minute apart or less.
+  #
+  # Each Revisions object also has an attribute <tt>cmd</tt> which should contain
+  # the command used to retrieve the revision data and populate it. This is useful
+  # for debugging an RSCM adapter that might behaving incorrectly. Keep in mind that
+  # it is the responsibility of each RSCM adapter implementation to set this attribute,
+  # and that it should omit setting it if the <tt>store_revisions_command</tt> is
+  # <tt>true</tt>
+  class Revisions
+    include Enumerable
+    attr_accessor :cmd
+    
+    def initialize(revisions=[])
+      @revisions = revisions
+    end
+
+    def add(file_or_revision)
+      if(file_or_revision.is_a?(Revision))
+        @revisions << file_or_revision
+      else
+        revision = find { |a_revision| a_revision.accept?(file_or_revision) }
+        if(revision.nil?)
+          revision = Revision.new
+          @revisions << revision
+        end
+        revision.add file_or_revision
+      end
+    end
+    
+    def sort!
+      @revisions.sort!{|r1,r2| r1.time<=>r2.time}
+    end
+        
+    def to_s
+      @revisions.collect{|revision| revision.to_s}.join("\n-----------")
+    end
+    
+    def ==(other)
+      self.to_s == other.to_s
+    end
+    
+    def each(&block)
+      @revisions.each(&block)
+    end
+
+    def [](n)
+      @revisions[n]
+    end
+
+    def length
+      @revisions.length
+    end
+
+    def empty?
+      @revisions.empty?
+    end
+  end
+end

data/lib/rscm/scm/clearcase.rb

@@ -6,15 +6,17 @@ require 'tempfile'
 module RSCM
   class ClearCase < Base
 
-    LOG_FORMAT = "- !ruby/object:RSCM::RevisionFile\\n  developer: %u\\n  time: \\\"%Nd\\\"\\n  native_revision_identifier: %Vn\\n  previous_native_revision_identifier: %PVn\\n  path: %En\\n  status: %o\\n  message: \\\"%Nc\\\"\\n\\n"
-    TIME_FORMAT = "%d-%b-%Y.%H:%M:%S"
-    MAGIC_TOKEN = "9q8w7e6r5t4y"
-    STATUSES = {
-      "checkin" => RevisionFile::MODIFIED,
-      "mkelem" => RevisionFile::ADDED,
-      "rmelem" => RevisionFile::DELETED,
-    }
-    DEFAULT_CONFIG_SPEC = "element * CHECKEDOUT\nelement * /main/LATEST"
+    unless defined? LOG_FORMAT
+      LOG_FORMAT = "- !ruby/object:RSCM::RevisionFile\\n  developer: %u\\n  time: \\\"%Nd\\\"\\n  native_revision_identifier: %Vn\\n  previous_native_revision_identifier: %PVn\\n  path: %En\\n  status: %o\\n  message: \\\"%Nc\\\"\\n\\n"
+      TIME_FORMAT = "%d-%b-%Y.%H:%M:%S"
+      MAGIC_TOKEN = "9q8w7e6r5t4y"
+      STATUSES = {
+        "checkin" => RevisionFile::MODIFIED,
+        "mkelem" => RevisionFile::ADDED,
+        "rmelem" => RevisionFile::DELETED,
+      }
+      DEFAULT_CONFIG_SPEC = "element * CHECKEDOUT\nelement * /main/LATEST"
+    end
 
     attr_accessor :stream, :stgloc, :tag, :config_spec
 

data/lib/rscm/scm/cvs.rb

@@ -1,352 +1,374 @@
-require 'stringio'
-require 'rscm/base'
-require 'rscm/path_converter'
-require 'rscm/line_editor'
-require 'rscm/scm/cvs_log_parser'
-
-module RSCM
-
-  # RSCM implementation for CVS.
-  #
-  # 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 < Base
-    attr_accessor :root
-    attr_accessor :mod
-    attr_accessor :branch
-    attr_accessor :password
-    
-    def initialize(root=nil, mod=nil, branch=nil, password=nil)
-      @root, @mod, @branch, @password = root, mod, branch, password
-    end
-
-    def import_central(options={})
-      modname = File.basename(options[:dir])
-      cvs("import -m \"#{options[:message]}\" #{modname} VENDOR START", options)
-    end
-    
-    def add(relative_filename, options={})
-      cvs("add #{relative_filename}", options)
-    end
-
-    def move(relative_src, relative_dest, options={})
-      FileUtils.mv(@checkout_dir + '/' + relative_src, @checkout_dir + '/' + relative_dest, :force=>true)
-      cvs("rm #{relative_src}", options)
-      # This will fail if the directories are new. More advanced support for adding can be added if needed.
-      cvs("add #{relative_dest}", options)
-    end
-
-    def commit(message, options={})
-      cvs(commit_command(message), options)
-    end
-
-    def uptodate?(identifier, options={})
-      if(!checked_out?)
-        return false
-      end
-
-      checkout_silent(identifier, options.dup.merge({:simulate => true})) do |io|
-        path_regex = /^[U|P|C] (.*)/
-        io.each_line do |line|
-          return false if(line =~ path_regex)
-        end
-      end
-      return true
-    end
-
-    def revisions(from_identifier, options={})
-      options = {
-        :from_identifier => from_identifier,
-        :to_identifier => Time.infinity, 
-        :relative_path => nil
-      }.merge(options)
-      checkout(options[:to_identifier], options) unless checked_out? # must checkout to get revisions
-      parse_log(changes_command(options), options)
-    end
-    
-    def diff(revision_file, options={})
-      opts = case revision_file.status
-        when /#{RevisionFile::MODIFIED}/; "#{revision_option(revision_file.previous_native_revision_identifier)} #{revision_option(revision_file.native_revision_identifier)}"
-        when /#{RevisionFile::DELETED}/; "#{revision_option(revision_file.previous_native_revision_identifier)}"
-        when /#{RevisionFile::ADDED}/; "#{revision_option(Time.epoch)} #{revision_option(revision_file.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} #{revision_file.path}")
-      execute(cmd, options.dup.merge({:exitstatus => 1})) do |io|
-        yield io
-      end
-    end
-    
-    def open(revision_file, options, &block)
-      cmd = "cvs -Q update -p -r #{revision_file.native_revision_identifier} #{revision_file.path}"
-      execute(cmd, options) do |io|
-        block.call io
-      end
-    end
-    
-    def apply_label(label)
-      cvs("tag -c #{label}")
-    end
-
-    def trigger_mechanism
-      "CVSROOT/loginfo"
-    end
-    
-    def trigger_installed?(trigger_command, trigger_files_checkout_dir, options={})
-      loginfo_line = "#{mod} #{trigger_command}"
-      regex = Regexp.new(Regexp.escape(loginfo_line))
-
-      root_cvs = create_root_cvs(trigger_files_checkout_dir)
-      begin
-        root_cvs.checkout(nil, options)
-        loginfo = File.join(trigger_files_checkout_dir, "loginfo")
-        return false if !File.exist?(loginfo)
-
-        # returns true if commented out. doesn't modify the file.
-        in_local_copy = LineEditor.comment_out(File.new(loginfo), regex, "# ", "")
-        # Also verify that loginfo has been committed back to the repo
-        entries = File.join(trigger_files_checkout_dir, "CVS", "Entries")
-        committed = File.mtime(entries) >= File.mtime(loginfo)
-
-        in_local_copy && committed
-      rescue Exception => e
-        $stderr.puts(e.message)
-        $stderr.puts(e.backtrace.join("\n"))
-        false
-      end
-    end
-
-    def install_trigger(trigger_command, trigger_files_checkout_dir, options={})
-      raise "mod can't be null or empty" if (mod.nil? || mod == "")
-
-      root_cvs = create_root_cvs(trigger_files_checkout_dir)
-      root_cvs.checkout(nil, options)
-      Dir.chdir(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
-      end
-
-      begin
-        root_cvs.commit("Installed trigger for CVS module '#{mod}'", options)
-      rescue Errno::EACCES
-        raise ["Didn't have permission to commit CVSROOT/loginfo.",
-              "Try to manually add the following line:",
-              trigger_command,
-              "Finally make commit the file to the repository"].join("\n")
-      end
-    end
-    
-    def uninstall_trigger(trigger_command, trigger_files_checkout_dir, options={})
-      loginfo_line = "#{mod} #{trigger_command}"
-      regex = Regexp.new(Regexp.escape(loginfo_line))
-
-      root_cvs = create_root_cvs(trigger_files_checkout_dir)
-      root_cvs.checkout nil, options
-      loginfo_path = File.join(trigger_files_checkout_dir, "loginfo")
-      File.comment_out(loginfo_path, regex, "# ")
-      root_cvs.commit("Uninstalled trigger for CVS mod '#{mod}'", options)
-      raise "Couldn't uninstall/commit trigger to loginfo" if trigger_installed?(trigger_command, trigger_files_checkout_dir, options)
-    end
-
-    def create_central(options={})
-      options = options.dup.merge({:dir => path})
-      raise "Can't create central CVS repository for #{root}" unless can_create_central?
-      File.mkpath(path)
-      cvs("init", options)
-    end
-
-    def destroy_central
-      if(File.exist?(path) && local?)
-        FileUtils.rm_rf(path)
-      else
-        raise "Cannot destroy central repository. '#{path}' doesn't exist or central repo isn't local to this machine"
-      end
-    end
-    
-    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
-        false
-      end
-    end
-
-    def supports_trigger?
-      true
-    end
-
-    def checked_out?
-      rootcvs = File.expand_path("#{checkout_dir}/CVS/Root")
-      File.exists?(rootcvs)
-    end
-
-  protected
-  
-    def checkout_silent(to_identifier, options={}, &proc)
-      to_identifier = nil if to_identifier == Time.infinity
-      if(checked_out?)
-        options = options.dup.merge({
-          :dir => @checkout_dir
-        })
-        cvs(update_command(to_identifier), options, &proc)
-      else
-        # This is a workaround for the fact that -d . doesn't work - must be an existing sub folder.
-        FileUtils.mkdir_p(@checkout_dir) unless File.exist?(@checkout_dir)
-        target_dir = File.basename(@checkout_dir)
-        # -D is sticky, but subsequent updates will reset stickiness with -A
-        options = options.dup.merge({
-          :dir => File.dirname(@checkout_dir)
-        })
-        cvs(checkout_command(target_dir, to_identifier), options, &proc)
-      end
-    end
-  
-    def ignore_paths
-      [/CVS\/.*/]
-    end
-    
-  private
-
-    def cvs(cmd, options={}, &proc)
-      options = {
-        :simulate => false,
-        :dir => @checkout_dir
-      }.merge(options)
-
-      options[:dir] = PathConverter.nativepath_to_filepath(options[:dir])
-      execed_command_line = command_line(cmd, password, options[:simulate])
-      execute(execed_command_line, options, &proc)
-    end
-
-    def parse_log(cmd, options, &proc)
-      execed_command_line = command_line(cmd, password)
-      revisions = nil
-
-      execute(execed_command_line, options) do |io|
-        parser = CvsLogParser.new(io)
-        parser.cvspath = path
-        parser.cvsmodule = mod
-        revisions = parser.parse_revisions
-      end
-      revisions
-    end
-
-    def changes_command(options)
-      # https://www.cvshome.org/docs/manual/cvs-1.11.17/cvs_16.html#SEC144
-      # -N => Suppress the header if no RevisionFiles are selected.
-      "log #{branch_option} -N #{period_option(options[:from_identifier], options[:to_identifier])} #{options[:relative_path]}"
-    end
-
-    def branch_specified?
-      branch && branch.strip != ""
-    end
-
-    def branch_option
-      branch_specified? ? "-r#{branch}" : ""
-    end
-
-    def update_command(to_identifier)
-      "update #{branch_option} -d -P -A #{revision_option(to_identifier)}"
-    end
-
-    def checkout_command(target_dir, to_identifier)
-      "checkout #{branch_option} -d #{target_dir} #{revision_option(to_identifier)} #{mod}"
-    end
-    
-    def period_option(from_identifier, to_identifier)
-      if(from_identifier.nil? && to_identifier.nil?)
-        ""
-      else
-        "-d\"#{cvsdate(from_identifier)}<#{cvsdate(to_identifier+1)}\" " 
-      end
-    end
-      
-    def cvsdate(time)
-      return "" unless time
-      # CVS wants all dates as UTC.
-      time.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
-    end
-    
-    def root_with_password(password)
-      result = nil
-      if local?
-        result = root
-      elsif password && password != ""
-        protocol, user, host, path = parse_cvs_root
-        result = ":#{protocol}:#{user}:#{password}@#{host}:#{path}"
-      else
-        result = root
-      end
-    end
-  
-    def command_line(cmd, password=nil, simulate=false)
-      cvs_options = simulate ? "-n" : ""
-      "cvs -f \"-d#{root_with_password(password)}\" #{cvs_options} -q #{cmd}"
-    end
-
-    def create_root_cvs(checkout_dir)
-      cvs = Cvs.new(self.root, "CVSROOT", nil, self.password)
-      cvs.checkout_dir = checkout_dir
-      cvs.default_options = default_options
-      cvs
-    end
-
-    def revision_option(identifier)
-      option = nil
-      if(identifier.is_a?(Time))
-        option = "-D\"#{cvsdate(identifier)}\""
-      elsif(identifier.is_a?(String))
-        option = "-r#{identifier}"
-      else
-        ""
-      end
-    end
-
-    def commit_command(message)
-      "commit -m \"#{message}\""
-    end
-
-    def local?
-      protocol == "local"
-    end
-    
-    def path
-      parse_cvs_root[3]
-    end
-    
-    def protocol
-      parse_cvs_root[0]
-    end
-    
-    # parses the root into tokens
-    # [protocol, user, host, path]
-    #
-    def parse_cvs_root
-      md = case
-        when root =~ /^:local:/   then /^:(local):(.*)/.match(root)
-        when root =~ /^:ext:/     then /^:(ext):(.*)@(.*):(.*)/.match(root)
-        when root =~ /^:pserver:/ then /^:(pserver):(.*)@(.*):(.*)/.match(root)
-      end
-      result = case
-        when root =~ /^:local:/   then [md[1], nil, nil, md[2]]
-        when root =~ /^:ext:/     then md[1..4]
-        when root =~ /^:pserver:/ then md[1..4]
-        else ["local", nil, nil, root]
-      end
-    end
-  end
-end
+require 'stringio'
+require 'rscm/base'
+require 'rscm/path_converter'
+require 'rscm/line_editor'
+require 'rscm/scm/cvs_log_parser'
+
+module RSCM
+
+  # RSCM implementation for CVS.
+  #
+  # 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 < Base
+    attr_accessor :root
+    attr_accessor :mod
+    attr_accessor :branch
+    attr_accessor :password
+    
+    def installed?
+      begin
+        cvs("--version", {}) 
+        true
+      rescue
+        false
+      end
+    end
+
+    def initialize(root=nil, mod=nil, branch=nil, password=nil)
+      @root, @mod, @branch, @password = root, mod, branch, password
+    end
+
+    def import_central(dir, options={})
+      modname = File.basename(dir)
+      FileUtils.mkdir_p(@checkout_dir) unless File.exist?(@checkout_dir)
+      options = options.dup.merge :dir => dir
+      cvs("import -m \"#{options[:message]}\" #{modname} VENDOR START", options)
+    end
+    
+    def add(relative_filename, options={})
+      cvs("add #{relative_filename}", options)
+    end
+
+    def move(relative_src, relative_dest, options={})
+      FileUtils.mv(@checkout_dir + '/' + relative_src, @checkout_dir + '/' + relative_dest, :force=>true)
+      cvs("rm #{relative_src}", options)
+      # This will fail if the directories are new. More advanced support for adding can be added if needed.
+      cvs("add #{relative_dest}", options)
+    end
+
+    def commit(message, options={})
+      cvs(commit_command(message), options)
+    end
+
+    def uptodate?(identifier, options={})
+      if(!checked_out?)
+        return false
+      end
+
+      checkout_silent(identifier, options.dup.merge({:simulate => true})) do |io|
+        path_regex = /^[U|P|C] (.*)/
+        io.each_line do |line|
+          return false if(line =~ path_regex)
+        end
+      end
+      return true
+    end
+
+    def revisions(from_identifier=Time.new.utc, options={})
+      raise "from_identifer cannot be nil" if from_identifier.nil?
+      options = {
+        :from_identifier => from_identifier,
+        :to_identifier => Time.infinity, 
+        :relative_path => nil
+      }.merge(options)
+      checkout(options[:to_identifier], options) unless checked_out? # must checkout to get revisions
+      parse_log(changes_command(options), options)
+    end
+    
+    def diff(path, from, to, options={}, &block)
+      # IMPORTANT! CVS NT has a bug in the -N diff option
+      # http://www.cvsnt.org/pipermail/cvsnt-bugs/2004-November/000786.html
+      from ||= Time.epoch
+      cmd = command_line("diff -Nu #{revision_option(from)} #{revision_option(to)} #{path}")
+      execute(cmd, options.dup.merge({:exitstatus => 1})) do |io|
+        block.call io
+      end
+    end
+
+    def open(path, native_revision_identifier, options={}, &block)
+      raise "native_revision_identifier cannot be nil" if native_revision_identifier.nil?
+      cmd = "cvs -Q update -p -r #{native_revision_identifier} #{path}"
+      execute(cmd, options) do |io|
+        block.call io
+      end
+    end
+    
+    def apply_label(label)
+      cvs("tag -c #{label}")
+    end
+
+    def trigger_mechanism
+      "CVSROOT/loginfo"
+    end
+    
+    def trigger_installed?(trigger_command, trigger_files_checkout_dir, options={})
+      trigger_command = fix_trigger_command(trigger_command)
+      loginfo_line = "#{mod} #{trigger_command}"
+      regex = Regexp.new(Regexp.escape(loginfo_line))
+
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
+      begin
+        root_cvs.checkout(nil, options)
+        loginfo = File.join(trigger_files_checkout_dir, "loginfo")
+        return false if !File.exist?(loginfo)
+
+        # returns true if commented out. doesn't modify the file.
+        in_local_copy = LineEditor.comment_out(File.new(loginfo), regex, "# ", "")
+        # Also verify that loginfo has been committed back to the repo
+        entries = File.join(trigger_files_checkout_dir, "CVS", "Entries")
+        committed = File.mtime(entries) >= File.mtime(loginfo)
+
+        in_local_copy && committed
+      rescue Exception => e
+        $stderr.puts(e.message)
+        $stderr.puts(e.backtrace.join("\n"))
+        false
+      end
+    end
+
+    def install_trigger(trigger_command, trigger_files_checkout_dir, options={})
+      raise "mod can't be null or empty" if (mod.nil? || mod == "")
+      trigger_command = fix_trigger_command(trigger_command)
+
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
+      root_cvs.checkout(nil, options)
+      Dir.chdir(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
+      end
+
+      begin
+        root_cvs.commit("Installed trigger for CVS module '#{mod}'", options)
+      rescue Errno::EACCES
+        raise ["Didn't have permission to commit CVSROOT/loginfo.",
+              "Try to manually add the following line:",
+              trigger_command,
+              "Finally make commit the file to the repository"].join("\n")
+      end
+    end
+    
+    def uninstall_trigger(trigger_command, trigger_files_checkout_dir, options={})
+      trigger_command = fix_trigger_command(trigger_command)
+      loginfo_line = "#{mod} #{trigger_command}"
+      regex = Regexp.new(Regexp.escape(loginfo_line))
+
+      root_cvs = create_root_cvs(trigger_files_checkout_dir)
+      root_cvs.checkout nil, options
+      loginfo_path = File.join(trigger_files_checkout_dir, "loginfo")
+      File.comment_out(loginfo_path, regex, "# ")
+      root_cvs.commit("Uninstalled trigger for CVS mod '#{mod}'", options)
+      raise "Couldn't uninstall/commit trigger to loginfo" if trigger_installed?(trigger_command, trigger_files_checkout_dir, options)
+    end
+
+    def create_central(options={})
+      options = options.dup.merge({:dir => path})
+      raise "Can't create central CVS repository for #{root}" unless can_create_central?
+      File.mkpath(path)
+      cvs("init", options)
+    end
+
+    def destroy_central
+      if(File.exist?(path) && local?)
+        FileUtils.rm_rf(path)
+      else
+        raise "Cannot destroy central repository. '#{path}' doesn't exist or central repo isn't local to this machine"
+      end
+    end
+    
+    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
+        false
+      end
+    end
+
+    def supports_trigger?
+      true
+    end
+
+    def checked_out?
+      rootcvs = File.expand_path("#{checkout_dir}/CVS/Root")
+      File.exists?(rootcvs)
+    end
+
+  protected
+  
+    def cmd_dir
+      @checkout_dir
+    end
+  
+    def checkout_silent(to_identifier, options={}, &proc)
+      to_identifier = nil if to_identifier == Time.infinity
+      if(checked_out?)
+        options = options.dup.merge({
+          :dir => @checkout_dir
+        })
+        cvs(update_command(to_identifier), options, &proc)
+      else
+        # This is a workaround for the fact that -d . doesn't work - must be an existing sub folder.
+        FileUtils.mkdir_p(@checkout_dir) unless File.exist?(@checkout_dir)
+        target_dir = File.basename(@checkout_dir)
+        # -D is sticky, but subsequent updates will reset stickiness with -A
+        options = options.dup.merge({
+          :dir => File.dirname(@checkout_dir)
+        })
+        cvs(checkout_command(target_dir, to_identifier), options, &proc)
+      end
+    end
+  
+    def ignore_paths
+      [/CVS\/.*/]
+    end
+    
+  private
+  
+    # Prepends a cat that will slurp stdin. Needed for triggers that don't read all of stdin passed
+    # from CVS to avoid broken pipe.
+    def fix_trigger_command(cmd)
+      "cat && #{cmd}"
+    end
+
+    def cvs(cmd, options={}, &proc)
+      options = {
+        :simulate => false,
+        :dir => @checkout_dir
+      }.merge(options)
+
+      options[:dir] = PathConverter.nativepath_to_filepath(options[:dir])
+      execed_command_line = command_line(cmd, password, options[:simulate])
+      execute(execed_command_line, options, &proc)
+    end
+
+    def parse_log(cmd, options, &proc)
+      execed_command_line = command_line(cmd, password)
+      revisions = nil
+
+      execute(execed_command_line, options) do |io|
+        parser = CvsLogParser.new(io)
+        parser.cvspath = path
+        parser.cvsmodule = mod
+        revisions = parser.parse_revisions
+      end
+      revisions.cmd = execed_command_line if store_revisions_command?
+      revisions
+    end
+
+    def changes_command(options)
+      # https://www.cvshome.org/docs/manual/cvs-1.11.17/cvs_16.html#SEC144
+      # -N => Suppress the header if no RevisionFiles are selected.
+      "log #{branch_option} -N #{period_option(options[:from_identifier], options[:to_identifier])} #{options[:relative_path]}"
+    end
+
+    def branch_specified?
+      branch && branch.strip != ""
+    end
+
+    def branch_option
+      branch_specified? ? "-r#{branch}" : ""
+    end
+
+    def update_command(to_identifier)
+      "update #{branch_option} -d -P -A #{revision_option(to_identifier)}"
+    end
+
+    def checkout_command(target_dir, to_identifier)
+      "checkout #{branch_option} -d #{target_dir} #{revision_option(to_identifier)} #{mod}"
+    end
+    
+    def period_option(from_identifier, to_identifier)
+      if(from_identifier.nil? && to_identifier.nil?)
+        ""
+      else
+        "-d\"#{cvsdate(from_identifier)}<#{cvsdate(to_identifier)}\" " 
+      end
+    end
+      
+    def cvsdate(time)
+      return "" unless time
+      # CVS wants all dates as UTC.
+      time.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+    end
+    
+    def root_with_password(password)
+      result = nil
+      if local?
+        result = root
+      elsif password && password != ""
+        protocol, user, host, path = parse_cvs_root
+        result = ":#{protocol}:#{user}:#{password}@#{host}:#{path}"
+      else
+        result = root
+      end
+    end
+  
+    def command_line(cmd, password=nil, simulate=false)
+      cvs_options = simulate ? "-n" : ""
+      "cvs -f \"-d#{root_with_password(password)}\" #{cvs_options} -q #{cmd}"
+    end
+
+    def create_root_cvs(checkout_dir)
+      cvs = Cvs.new(self.root, "CVSROOT", nil, self.password)
+      cvs.checkout_dir = checkout_dir
+      cvs.default_options = default_options
+      cvs
+    end
+
+    def revision_option(identifier)
+      option = nil
+      if(identifier.is_a?(Time))
+        option = "-D\"#{cvsdate(identifier)}\""
+      elsif(identifier.is_a?(String))
+        option = "-r#{identifier}"
+      else
+        ""
+      end
+    end
+
+    def commit_command(message)
+      "commit -m \"#{message}\""
+    end
+
+    def local?
+      protocol == "local"
+    end
+    
+    def path
+      parse_cvs_root[3]
+    end
+    
+    def protocol
+      parse_cvs_root[0]
+    end
+    
+    # parses the root into tokens
+    # [protocol, user, host, path]
+    #
+    def parse_cvs_root
+      md = case
+        when root =~ /^:local:/   then /^:(local):(.*)/.match(root)
+        when root =~ /^:ext:/     then /^:(ext):(.*)@(.*):(.*)/.match(root)
+        when root =~ /^:pserver:/ then /^:(pserver):(.*)@(.*):(.*)/.match(root)
+      end
+      result = case
+        when root =~ /^:local:/   then [md[1], nil, nil, md[2]]
+        when root =~ /^:ext:/     then md[1..4]
+        when root =~ /^:pserver:/ then md[1..4]
+        else ["local", nil, nil, root]
+      end
+    end
+  end
+end