whistle 0.1

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

@@ -0,0 +1,109 @@
+require 'rscm'
+require 'time'
+require 'stringio'
+
+module RSCM
+
+  class MonotoneLogParser
+  
+    def parse_revisions(io, from_identifier=Time.epoch, to_identifier=Time.infinity)
+      # skip first separator
+      io.readline
+      
+      all_revisions = []
+      revision_string = ""
+      
+      # hash of path => [array of revisions]
+      path_revisions = {}
+      io.each_line do |line|
+        if(line =~ /-----------------------------------------------------------------/)
+          revision = parse_revision(StringIO.new(revision_string), path_revisions)
+          all_revisions << revision
+          revision_string = ""
+        else
+          revision_string << line
+        end
+      end
+      revision = parse_revision(StringIO.new(revision_string), path_revisions)
+      all_revisions << revision
+      
+      # Filter out the revisions and set the previous revisions, knowing that most recent is at index 0.
+
+      from_time = time(all_revisions, from_identifier, Time.epoch)
+      to_time = time(all_revisions, to_identifier, Time.infinity)
+
+      revisions = Revisions.new
+
+      all_revisions.each do |revision|
+        if((from_time < revision.time) && (revision.time <= to_time))
+          revisions.add(revision)
+          revision.each do |change|
+            current_index = path_revisions[change.path].index(change.native_revision_identifier)
+            change.previous_native_revision_identifier = path_revisions[change.path][current_index + 1]
+          end
+        end
+      end
+      revisions
+    end
+    
+    def parse_revision(revision_io, path_revisions)
+      revision = Revision.new
+      state = nil
+      revision_io.each_line do |line|
+        if(line =~ /^Revision: (.*)$/ && revision.identifier.nil?)
+          revision.identifier =  $1
+        elsif(line =~ /^Author: (.*)$/ && revision.developer.nil?)
+          revision.developer = $1
+        elsif(line =~ /^Date: (.*)$/ && revision.time.nil?)
+          revision.time = Time.utc(
+            $1[0..3].to_i,
+            $1[5..6].to_i,
+            $1[8..9].to_i,
+            $1[11..12].to_i,
+            $1[14..15].to_i,
+            $1[17..18].to_i
+          )
+        elsif(line =~ /^ChangeLog:\s*$/ && revision.message.nil?)
+          state = :message
+        elsif(state == :message && revision.message.nil?)
+          revision.message = ""
+        elsif(state == :message && revision.message)
+          revision.message << line
+        elsif(line =~ /^Added files:\s*$/)
+          state = :added
+        elsif(state == :added)
+          add_changes(revision, line, RevisionFile::ADDED, path_revisions)
+        elsif(line =~ /^Modified files:\s*$/)
+          state = :modified
+        elsif(state == :modified)
+          add_changes(revision, line, RevisionFile::MODIFIED, path_revisions)
+        end
+      end
+      revision.message.chomp! rescue revision.message = ''
+      revision
+    end
+    
+  private
+
+    def time(revisions, identifier, default)
+      cs = revisions.find do |revision|
+        revision.identifier == identifier
+      end
+      cs ? cs.time : (identifier.is_a?(Time) ? identifier : default)
+    end
+
+    def add_changes(revision, line, state, path_revisions)
+      paths = line.split(" ")
+      paths.each do |path|
+        revision << RevisionFile.new(path, state, revision.developer, nil, revision.identifier, revision.time)
+
+        # now record path revisions so we can keep track of previous rev for each path
+        # doesn't work for moved files, and have no idea how to make it work either.
+        path_revisions[path] ||= [] 
+        path_revisions[path] << revision.identifier
+      end
+      
+    end
+  end
+
+end

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

@@ -0,0 +1,6 @@
+require 'rscm/base'
+
+module RSCM
+  class Mooky < Base
+  end
+end

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

@@ -0,0 +1,216 @@
+# TODO
+# Support int revision numbers AND dates
+# Leverage default P4 client settings (optional)
+
+require 'rscm/base'
+require 'rscm/path_converter'
+require 'rscm/line_editor'
+
+require 'fileutils'
+require 'time'
+require 'socket'
+
+module RSCM
+  class Perforce < Base
+    unless defined? DATE_FORMAT
+      DATE_FORMAT = "%Y/%m/%d:%H:%M:%S"
+      # Doesn't work for empty messages, (Like 21358 in Aslak's P4 repo)
+      CHANGELIST_PATTERN = /^Change \d+ by (.*)@.* on (.*)\n\n(.*)\n\nAffected files ...\n\n(.*)/m
+      # But this one does
+      CHANGELIST_PATTERN_NO_MSG = /^Change \d+ by (.*)@.* on (.*)\n\nAffected files ...\n\n(.*)/m
+      
+      STATES = {
+        "add" => RevisionFile::ADDED,
+        "edit" => RevisionFile::MODIFIED,
+        "delete" => RevisionFile::DELETED
+      }
+    end
+
+    attr_accessor :view
+    attr_accessor :username
+    attr_accessor :password
+
+    def installed?
+      begin
+        execute("p4 info", {}) 
+        true
+      rescue
+        false
+      end
+    end
+
+    def revisions(from_identifier=Time.new.utc, options={})
+      raise "from_identifer cannot be nil" if from_identifier.nil?
+      set_utc_offset(options)
+      view_as_regexp = "^" + @view.gsub(/\.\.\./, "(.*)")
+      relative_path_pattern = Regexp.new(view_as_regexp)
+    
+      from_identifier = Time.epoch unless from_identifier
+      from_identifier = Time.epoch if (from_identifier.is_a? Time and from_identifier < Time.epoch)
+      from = revision_spec(from_identifier + 1) # We have to add 1 because of the contract of this method.
+
+      to_identifier = options[:to_identifier] ? options[:to_identifier] : Time.infinity
+      to = revision_spec(to_identifier - 1) # We have to subtract 1 because of the contract of this method.
+
+      cmd = "p4 #{p4_opts(false)} changes #{@view}@#{from},#{to}"
+      revisions = Revisions.new
+      revisions.cmd = cmd if store_revisions_command?
+
+      changes = execute(cmd, options) do |io|
+        io.read
+      end
+
+      changes.each do |line|
+        revision = nil
+        identifier = line.match(/^Change (\d+)/)[1].to_i
+
+        execute("p4 #{p4_opts(false)} describe -s #{identifier}", options) do |io|
+          log = io.read
+
+          if log =~ CHANGELIST_PATTERN
+            developer, time, message, files = $1, $2, $3, $4
+          elsif log =~ CHANGELIST_PATTERN_NO_MSG
+            developer, time, files = $1, $2, $3
+          else
+            puts "PARSE ERROR:"
+            puts log
+            puts "\nDIDN'T MATCH:"
+            puts CHANGELIST_PATTERN
+          end
+
+          # The parsed time doesn't have timezone info. We'll tweak it.
+          time = Time.parse(time + " UTC") - @utc_offset
+
+          files.each_line do |line|
+            if line =~ /^\.\.\. (\/\/.+)#(\d+) (.+)/
+              depot_path = $1
+              file_identifier = $2.to_i
+              state = $3.strip
+              if(STATES[state])
+                if(depot_path =~ relative_path_pattern)
+                  relative_path = $1
+
+                  if revision.nil?
+                    revision = Revision.new
+                    revision.identifier = identifier
+                    revision.developer = developer
+                    revision.message = message
+                    revision.time = time
+                    revisions.add revision
+                  end
+
+                  file = RevisionFile.new
+                  file.path = relative_path
+                  file.native_revision_identifier = file_identifier
+                  file.previous_native_revision_identifier = file.native_revision_identifier-1
+                  file.status = STATES[state]
+                  revision.add file
+                end
+              end
+            end
+          end
+        end
+      end
+      revisions
+    end
+    
+    def destroy_working_copy(options={})
+      execute("p4 #{p4_opts(false)} client -d #{client_name}", options)
+    end
+
+    def open(revision_file, options={}, &block)
+      path = @view.gsub(/\.\.\./, revision_file.path) # + "@" + revision_file.native_revision_identifier
+      cmd = "p4 #{p4_opts(false)} print -q #{path}"
+      execute(cmd, options) do |io|
+        block.call io
+      end
+    end
+    
+    def diff
+    #p4 diff2 //depot/trunk/build.xml@26405 //depot/trunk/build.xml@26409
+    end
+
+  protected
+
+    def checkout_silent(to_identifier, options)
+      checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
+      FileUtils.mkdir_p(@checkout_dir)
+      
+      ensure_client(options)
+      execute("p4 #{p4_opts} sync #{@view}@#{to_identifier}", options)
+    end
+
+    def ignore_paths
+      []
+    end
+    
+  private
+  
+    def p4_opts(with_client=true)
+      user_opt = @username.to_s.empty? ? "" : "-u #{@username}"
+      password_opt = @password.to_s.empty? ? "" : "-P #{@password}"
+      client_opt = with_client ? "-c \"#{client_name}\"" : ""
+      "#{user_opt} #{password_opt} #{client_opt}"
+    end
+    
+    def client_name
+      raise "checkout_dir not set" unless @checkout_dir
+      Socket.gethostname + ":" + @checkout_dir
+    end
+    
+    def ensure_client(options)
+      create_client(options)
+    end
+    
+    def create_client(options)
+      options = {:mode => "w+"}.merge(options)
+      FileUtils.mkdir_p(@checkout_dir)
+      execute("p4 #{p4_opts(false)} client -i", options) do |io|
+        io.puts(client_spec)
+        io.close_write
+      end
+    end
+    
+    def client_spec
+      <<-EOF
+Client: #{client_name}
+Owner: #{@username}
+Host: #{Socket.gethostname}
+Description: RSCM client
+Root: #{@checkout_dir}
+Options: noallwrite noclobber nocompress unlocked nomodtime normdir
+LineEnd: local
+View: #{@view} //#{client_name}/...
+EOF
+    end
+    
+    def revision_spec(identifier)
+      if identifier.is_a?(Time)
+        # The p4 client uses local time, but rscm uses utc
+        # We have to convert to local time
+        identifier += @utc_offset
+        identifier.strftime(DATE_FORMAT)
+      else
+        identifier.to_i
+      end
+    end
+
+    # Queries the server for the time offset. Required in order to get proper
+    # timezone for revisions
+    def set_utc_offset(options)
+      unless @utc_offset
+        execute("p4 #{p4_opts(false)} info", options) do |io|
+          io.each do |line|
+            if line =~ /^Server date: (.*)/
+              server_time = Time.parse($1)
+              @utc_offset = server_time.utc_offset
+            end
+          end
+        end
+        raise "Couldn't get server's UTC offset" if @utc_offset.nil?
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,104 @@
+require 'fileutils'
+require 'tempfile'
+require 'rscm/revision'
+require 'rscm/base'
+require 'yaml'
+
+class Time
+  def to_rfc2822
+    utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+  end
+end
+
+module RSCM
+  # The RSCM StarTeam class requires that the following software be installed:
+  #
+  # * Java Runtime (1.4.2)
+  # * StarTeam SDK
+  # * Apache Ant (http://ant.apache.org/)
+  #
+  class StarTeam < Base
+    attr_accessor :user_name
+    attr_accessor :password
+    attr_accessor :server_name
+    attr_accessor :server_port
+    attr_accessor :project_name
+    attr_accessor :view_name
+    attr_accessor :folder_name
+
+    def initialize(user_name="", password="", server_name="", server_port="", project_name="", view_name="", folder_name="")
+      @user_name, @password, @server_name, @server_port, @project_name, @view_name, @folder_name = user_name, password, server_name, server_port, project_name, view_name, folder_name
+    end
+
+    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      
+
+      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(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
+      revisions
+    end
+
+    def checkout(checkout_dir, to_identifier, &proc)
+      # TODO: Take the to_identifier arg into consideration
+      files = java("checkout(\"#{checkout_dir}\")", &proc)
+      files
+    end
+
+    def supports_trigger?
+      true
+    end
+    
+  private
+  
+    def cmd
+      rscm_jar = File.expand_path(File.dirname(__FILE__) + "../../../../ext/rscm.jar")
+      starteam_jars = Dir["#{ENV['RSCM_STARTEAM']}/Lib/*jar"].join(File::PATH_SEPARATOR)
+      ant_jars = Dir["#{ENV['ANT_HOME']}/lib/*jar"].join(File::PATH_SEPARATOR)
+      classpath = "#{rscm_jar}#{File::PATH_SEPARATOR}#{ant_jars}#{File::PATH_SEPARATOR}#{starteam_jars}"
+
+      "java -Djava.library.path=\"#{ENV['RSCM_STARTEAM']}#{File::SEPARATOR}Lib\" -classpath \"#{classpath}\" org.rubyforge.rscm.Main"
+    end
+
+    def java(m, &proc)
+      raise "The RSCM_STARTEAM environment variable must be defined and point to the StarTeam SDK directory" unless ENV['RSCM_STARTEAM']
+      raise "The ANT_HOME environment variable must be defined and point to the Ant installation directory" unless ENV['ANT_HOME']
+
+      clazz = "org.rubyforge.rscm.starteam.StarTeam"
+      ctor_args = "#{@user_name};#{@password};#{@server_name};#{@server_port};#{@project_name};#{@view_name};#{@folder_name}"
+
+#     Uncomment if you're not Aslak - to run against a bogus java class.
+#      clazz = "org.rubyforge.rscm.TestScm"
+#      ctor_args = "hubba;bubba"
+
+      command = "new #{clazz}(#{ctor_args}).#{m}"
+      tf = Tempfile.new("rscm_starteam")
+      tf.puts(command)
+      tf.close 
+      cmdline = "#{cmd} #{tf.path}"
+      IO.popen(cmdline) do |io|
+        yaml_source = io
+        if(block_given?)
+          yaml_source = ""
+          io.each_line do |line|
+            yield line
+            yaml_source << line << "\n"
+          end
+        else
+        end
+        YAML::load(yaml_source)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,397 @@
+require 'rscm/base'
+require 'rscm/path_converter'
+require 'rscm/line_editor'
+require 'rscm/scm/subversion_log_parser'
+require 'stringio'
+
+module RSCM
+
+  # RSCM implementation for Subversion.
+  #
+  # You need the svn/svnadmin executable on the PATH in order for it to work.
+  #
+  # NOTE: On Cygwin these have to be the win32 builds of svn/svnadmin and not the Cygwin ones.
+  class Subversion < Base
+    
+    include FileUtils
+    include PathConverter
+    
+    attr_accessor :url
+    # Must be specified in order to create repo and install triggers. 
+    # Must also be specified as "" if the url represents the root of the repository, or files in revisions will not be detected.
+    attr_accessor :path
+    attr_accessor :username
+    attr_accessor :password
+
+    def initialize(url="", path="")
+      @url, @path = url, path
+      @username = ""
+      @password = ""
+    end
+    
+    def path
+      @path ||= ""
+    end
+
+    def installed?
+      begin
+        svn("--version", {}) 
+        true
+      rescue
+        false
+      end
+    end
+
+    def to_identifier(raw_identifier)
+      raw_identifier.to_i
+    end
+    
+    def add(relative_filename, options={})
+      svn("add #{checkout_dir}/#{relative_filename}", options)
+    end
+
+    def move(relative_src, relative_dest, options={})
+      svn("mv #{checkout_dir}/#{relative_src} #{checkout_dir}/#{relative_dest}", options)
+    end
+
+    def transactional?
+      true
+    end
+
+    def uptodate?(identifier, options={})
+      if(!checked_out?)
+        false
+      else
+        rev = identifier.nil? ? head_revision_identifier(options) : identifier 
+        local_revision_identifier(options) == rev
+      end
+    end
+
+    def commit(message, options={})
+      svn(commit_command(message), options)
+      # We have to do an update to get the local revision right
+      checkout_silent(nil, options)
+    end
+
+    def label
+      local_revision_identifier.to_s
+    end
+
+    def diff(path, from, to, options={}, &block)
+      cmd = "svn diff --revision #{from}:#{to} \"#{url}/#{path}\""
+      execute(cmd, options) do |io|
+        return(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 = "svn cat #{url}/#{path}@#{native_revision_identifier}"
+      execute(cmd, options) do |io|
+        return(block.call(io))
+      end
+    end
+
+    def can_create_central?
+      local? && !path.nil? && !(path == "")
+    end
+
+    def destroy_central
+      if(File.exist?(svnrootdir) && local?)
+        FileUtils.rm_rf(svnrootdir)
+      else
+        raise "Cannot destroy central repository. '#{svnrootdir}' doesn't exist or central repo isn't local to this machine"
+      end
+    end
+
+    def central_exists?
+      if(local?)
+        File.exists?("#{svnrootdir}/db")
+      else
+        # Do a simple command over the network
+        # If the repo/path doesn't exist, we'll get zero output
+        # on stdout (and an error msg on std err).
+        exists = false
+        cmd = "svn log #{url} -r HEAD"
+        execute(cmd) do |stdout|
+          stdout.each_line do |line|
+            exists = true
+          end
+        end
+        exists
+      end
+    end
+
+    def supports_trigger?
+      true
+      # we'll assume it supports trigger even if not local. this is to ensure user interfaces
+      # can display appropriate options, even if the object is not 'fully initialised'
+      # local?
+    end
+
+    def trigger_mechanism
+      "hooks/post-commit"
+    end
+    
+    def create_central(options={})
+      options = options.dup.merge({:dir => svnrootdir})
+      native_path = PathConverter.filepath_to_nativepath(svnrootdir, false)
+      mkdir_p(PathConverter.nativepath_to_filepath(native_path))
+      svnadmin("create #{native_path}", options)
+      if(path != "")
+        options = options.dup.merge({:dir => "."})
+        # create the directories
+        paths = path.split("/")
+        paths.each_with_index do |p,i|
+          p = paths[0..i]
+          u = "#{repourl}/#{p.join('/')}"
+          svn("mkdir #{u} -m \"Adding directories\"", options)
+        end
+      end
+    end
+
+    def install_trigger(trigger_command, trigger_files_checkout_dir, options={})
+      if (WINDOWS)
+        install_win_trigger(trigger_command, trigger_files_checkout_dir, options)
+      else
+        install_unix_trigger(trigger_command, trigger_files_checkout_dir, options)
+      end
+    end
+    
+    def uninstall_trigger(trigger_command, trigger_files_checkout_dir, options={})
+      File.comment_out(post_commit_file, /#{Regexp.escape(trigger_command)}/, nil)
+    end
+    
+    def trigger_installed?(trigger_command, trigger_files_checkout_dir, options={})
+      return false unless File.exist?(post_commit_file)
+      not_already_commented = LineEditor.comment_out(File.new(post_commit_file), /#{Regexp.escape(trigger_command)}/, "# ", "")
+      not_already_commented
+    end
+    
+    def import_central(dir, options={})
+      import_cmd = "import #{dir} #{url} -m \"#{options[:message]}\""
+      svn(import_cmd, options)
+    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 => "",
+        :dir => Dir.pwd
+      }.merge(options)
+      
+      checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
+      revisions = nil
+      command = "svn #{changes_command(options[:from_identifier], options[:to_identifier], options[:relative_path])}"
+      execute(command, options) do |stdout|
+        stdout = StringIO.new(stdout.read)
+        parser = SubversionLogParser.new(stdout, @url, options[:from_identifier], options[:to_identifier], path)
+        revisions = parser.parse_revisions
+      end
+      revisions.cmd = command if store_revisions_command?
+      revisions
+    end
+    
+    # url pointing to the root of the repo
+    def repourl
+      last = (path.nil? || path == "") ? -1 : -(path.length)-2
+      url[0..last]
+    end
+
+    def checked_out?
+      rootentries = File.expand_path("#{checkout_dir}/.svn/entries")
+      result = File.exists?(rootentries)
+      result
+    end
+
+  protected
+
+    def checkout_silent(to_identifier, options)
+      checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
+      mkdir_p(@checkout_dir)
+      if(checked_out?)
+        svn(update_command(to_identifier), options)
+      else
+        svn(checkout_command(to_identifier), options)
+      end
+    end
+
+    def ignore_paths
+      [/\.svn\/.*/]
+    end
+
+  private
+
+    def local_revision_identifier(options)
+      local_revision_identifier = nil
+      svn("info #{quoted_checkout_dir}", options) do |line|
+        if(line =~ /Revision: ([0-9]*)/)
+          return $1.to_i
+        end
+      end
+    end
+
+    def head_revision_identifier(options)
+      # 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}"
+      execute(cmd, options) do |stdout|
+        parser = SubversionLogParser.new(stdout, @url)
+        revisions = parser.parse_revisions
+        revisions[0].identifier
+      end
+    end
+
+    def install_unix_trigger(trigger_command, damagecontrol_install_dir, options)
+      post_commit_exists = File.exists?(post_commit_file)
+      mode = post_commit_exists ? File::APPEND|File::WRONLY : File::CREAT|File::WRONLY
+      begin
+        File.open(post_commit_file, mode) do |file|
+          file.puts("#!/bin/sh") unless post_commit_exists 
+          file.puts("#{trigger_command}\n" )
+        end
+        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:",
+              trigger_command,
+              "Finally make it executable with chmod g+x #{post_commit_file}"]
+      end
+    end
+    
+    def install_win_trigger(trigger_command, damagecontrol_install_dir, options)
+      post_commit_exists = File.exists?(post_commit_file)
+      mode = post_commit_exists ? File::APPEND|File::WRONLY : File::CREAT|File::WRONLY
+      begin
+        File.open(post_commit_file, mode) do |file|
+          file.puts("#{trigger_command}\n" )
+        end
+      rescue
+        raise ["Didn't have permission to write to #{post_commit_file}.",
+              "Try to manually add the following line:",
+              trigger_command]
+      end
+    end
+    
+    def svnrootdir
+      last = (path.nil? || path == "") ? -1 : -(path.length)-2
+      result = url["file://".length..last]
+      # for windows, turn /c:/blabla into c:/blabla"
+      if(result =~ /^\/[a-zA-Z]:/)
+        result = result[1..-1]
+      end
+      result
+    end
+
+    def svnadmin(cmd, options={}, &proc)
+      svncommand("svnadmin", cmd, options, &proc)
+    end
+
+    def svn(cmd, options={}, &proc)
+      svncommand("svn", cmd, options, &proc)
+    end
+
+    def svncommand(executable, cmd, options, &proc)
+      command_line = "#{executable} #{cmd}"
+      execute(command_line, options) do |stdout|
+        stdout.each_line do |line|
+          yield line if block_given?
+        end
+      end
+    end
+    
+    def checkout_command(to_identifier)
+      "checkout #{login_options} #{url} #{revision_option(nil,to_identifier)} #{quoted_checkout_dir}"
+    end
+
+    def update_command(to_identifier)
+      "update #{login_options} #{revision_option(nil,to_identifier)} #{quoted_checkout_dir}"
+    end
+    
+    def changes_command(from_identifier, to_identifier, relative_path)
+      # http://svnbook.red-bean.com/svnbook-1.1/svn-book.html#svn-ch-3-sect-3.3
+      # file_list = files.join('\n')
+      "log --verbose #{login_options} #{revision_option(from_identifier, to_identifier)} #{@url}"
+    end
+
+    def login_options
+      result = ""
+      u = @username ? @username.strip : ""
+      p = @password ? @password.strip : ""
+      result << "--username #{u} " unless u == ""
+      result << "--password #{p} " unless 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)
+      elsif(from_identifier.is_a?(Numeric))
+        from = from_identifier
+      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)
+      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
+      if(from && to.nil?)
+        revision_option = "--revision #{from}:HEAD"
+      elsif(from.nil? && to)
+        revision_option = "--revision #{to}"
+      elsif(from.nil? && to.nil?)
+        revision_option = ""
+      elsif(from && to)
+        revision_option = "--revision #{from}:#{to}"
+      end
+      revision_option
+    end
+    
+    def svndate(time)
+      return nil unless time
+      time.utc.strftime("{\"%Y-%m-%d %H:%M:%S\"}")
+    end
+
+    def commit_command(message)
+      "commit #{login_options} --force-log -m \"#{message}\" #{quoted_checkout_dir}"
+    end
+    
+    def quoted_checkout_dir
+      cd = '"' + PathConverter.filepath_to_nativepath(checkout_dir, false) + '"'
+      raise "checkout_dir not set" if cd == ""
+      cd
+    end
+    
+    def local?
+      if(url =~ /^file:/)
+        return true
+      else
+        return false
+      end
+    end
+
+    def post_commit_file
+      # We actualy need to use the .cmd when on cygwin. The cygwin svn post-commit
+      # hook is hosed. We'll be relying on native windows
+      if(local?)
+        WINDOWS ? "#{svnrootdir}/hooks/post-commit.cmd" : "#{svnrootdir}/hooks/post-commit"
+      else
+        raise "The repository is not local. Cannot install or uninstall trigger."
+      end
+    end
+    
+  end
+end