whistle 0.1

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/revision_file.rb

@@ -0,0 +1,85 @@
+module RSCM
+  # Represents a file within a Revision, and also information about how this file
+  # was modified compared with the previous revision.
+  class RevisionFile
+
+    MODIFIED = "MODIFIED"
+    DELETED = "DELETED"
+    ADDED = "ADDED"
+    MOVED = "MOVED"
+    
+    # MODIFIED, DELETED, ADDED or MOVED
+    attr_accessor :status
+    
+    # Relative path from the root of the RSCM::Base instance
+    attr_accessor :path
+
+    # The native SCM's previous revision for this file. For non-transactional SCMs this is different from
+    # the parent Revision's 
+    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
+
+    # The developer who modified this file
+    attr_accessor :developer
+    
+    # The commit message for this file
+    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 to_yaml_properties #:nodoc:
+      # We remove properties that are duplicated in the parent revision.
+      props = instance_variables
+      props.delete("@developer")
+      props.delete("@message")
+      props.delete("@time")
+      props.sort!
+    end
+    
+    # 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(path, native_revision_identifier, options, &block)
+    end
+    
+    # Yields the diff as an IO for this file
+    def diff(scm, 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)+ 
+    def accept(visitor)
+      visitor.visit_file(self)
+    end
+
+    # A simple string representation. Useful for debugging.
+    def to_s
+      "#{path} | #{native_revision_identifier}"
+    end
+
+    def ==(other)
+      return false if !other.is_a?(self.class)
+      self.status == other.status &&
+      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/vendor/rscm-0.5.1-patched-stripped/lib/rscm/revision_poller.rb

@@ -0,0 +1,93 @@
+module RSCM
+  module RevisionPoller
+    attr_accessor :logger
+  
+    # 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 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
+        point_time = now
+        point_identifier = point
+      end
+
+      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
+        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
+
+      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
+      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/vendor/rscm-0.5.1-patched-stripped/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/vendor/rscm-0.5.1-patched-stripped/lib/rscm/scm/clearcase.rb

@@ -0,0 +1,182 @@
+require 'rscm/base'
+require 'rscm/path_converter'
+require 'fileutils'
+require 'tempfile'
+
+module RSCM
+  class ClearCase < Base
+
+    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
+
+    def initialize(stream=nil, stgloc=nil, tag=nil, config_spec=DEFAULT_CONFIG_SPEC)
+      @stream, @stgloc, @tag, @config_spec = stream, stgloc, tag, config_spec
+    end
+
+    def revisions(from_identifier, options={})
+      options = {
+        :from_identifier => from_identifier,
+        :to_identifier => Time.infinity, 
+        :relative_path => nil
+      }.merge(options)
+
+      checkout unless checked_out?
+      rules = load_rules
+      vob = vob(rules[0])
+      result = Revisions.new
+      
+      unless vob
+        STDERR.puts "No vob found. Please set load rules in the view: #{checkout_dir}"
+        return result 
+      end
+      with_working_dir(checkout_dir) do
+        since = (from_identifier + 1).strftime(TIME_FORMAT)
+        cmd = "cleartool lshistory -recurse -nco -since #{since} -fmt \"#{LOG_FORMAT}\" -pname #{vob}"
+        execute(cmd, options) do |io|
+          # escape all quotes, except the one at the beginning and end. this is a bit ugly...
+          raw_yaml = io.read
+          fixed_yaml = raw_yaml.gsub(/^  message: \"/, "  message: #{MAGIC_TOKEN}")
+          fixed_yaml = fixed_yaml.gsub(/\"\n\n/, "#{MAGIC_TOKEN}\n\n")
+          fixed_yaml = fixed_yaml.gsub(/\"/, "\\\"")
+          fixed_yaml = fixed_yaml.gsub(MAGIC_TOKEN, "\"")
+ 
+          files = YAML.load(fixed_yaml)
+          files.each do |file|
+            file.path.gsub!(/\\/, "/")
+            file.status = STATUSES[file.status]
+            rev = revision(file.native_revision_identifier)
+            if(rev && matches_load_rules?(rules, file.path))
+              file.native_revision_identifier = rev
+              file.previous_native_revision_identifier = revision(file.previous_native_revision_identifier)
+              t = file.time
+              # the time now has escaped quotes..
+              file.time = Time.utc(t[2..5],t[6..7],t[8..9],t[11..12],t[13..14],t[15..16])
+              file.message.strip!
+              result.add(file)
+            end
+          end
+        end
+      end
+      result
+    end
+
+    def checked_out?
+      !Dir["#{checkout_dir}/*"].empty?
+    end
+
+    def destroy_working_copy(options={})
+      execute("cleartool rmview #{checkout_dir}", options) do |io|
+        io.read
+      end
+    end
+    
+    def import_central(options={})
+      execute("clearfsimport -recurse -nsetevent #{options[:dir]} #{checkout_dir}", options) do |io|
+        io.read
+      end
+    end
+    
+    ## Non-RSCM API methods
+
+    def mkview!(options={})
+       # Create view (working copy)
+       mkview_cmd = "cleartool mkview -snapshot -stream #{@stream} -stgloc #{@stgloc} -tag #{@tag} #{@checkout_dir}"
+       execute(mkview_cmd, options) do |io|
+         puts io.read
+       end
+    end
+
+    def update_load_rules!(options={})
+      Dir.chdir(checkout_dir) do
+        # tempfile is broken on windows (!!)
+        cfg_spec_file = "__rscm.cfgspec"
+        config_spec_file = File.open(cfg_spec_file, "w") do |io|
+          io.write(@config_spec)
+        end
+
+        setcs_cmd = "cleartool setcs #{cfg_spec_file}"
+        Better.popen(setcs_cmd, "w") do |io|
+          io.write "yes\n"
+        end
+      end
+    end
+
+    def catcs(options={})
+      Dir.chdir(checkout_dir) do
+        catcs_cmd = "cleartool catcs"
+        execute(catcs_cmd, options) do |io|
+          yield io
+        end
+      end
+    end
+
+    def vob(load_rule)
+      if(load_rule =~ /[\\\/]*([\w]*)/)
+        $1
+      else
+        nil
+      end
+    end
+
+    # What's loaded into view
+    def load_rules
+      result = []
+      catcs do |io|
+        io.each_line do |line|
+          if(line =~ /^load[\s]*(.*)$/)
+            return result << $1
+          end
+        end
+      end
+      result
+    end
+
+  protected
+
+    def checkout_silent(to_identifier, options={}, &proc)
+      if(checked_out?)
+        execute("cleartool update .", options)
+      else
+        mkview!
+ 
+        # Set load rules (by setting config spec)
+        #update_load_rules!
+      end
+    end
+
+    # Administrative files that should be ignored when counting files.
+    def ignore_paths
+      return [/.*\.updt/]
+    end
+
+  private
+
+    def revision(s)
+      if(s =~ /.*\\([\d]*)/)
+        $1.to_i
+      else
+        nil
+      end
+    end
+
+    def matches_load_rules?(rules, path)
+      rules.each do |rule|
+        rule.gsub!(/\\/, "/")
+        return true if path =~ /#{rule[1..-1]}/
+      end
+      false
+    end
+
+  end
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/scm/cvs.rb

@@ -0,0 +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 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