whistle 0.1

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

@@ -0,0 +1,154 @@
+require 'rscm/revision'
+require 'rscm/abstract_log_parser'
+require 'ftools'
+require 'time'
+
+module RSCM
+
+  class CvsLogParser < AbstractLogParser
+    REVISION_SEPARATOR = /^----------------------------$/ unless defined? REVISION_SEPARATOR
+    ENTRY_SEPARATOR = /^=============================================================================$/ unless defined? ENTRY_SEPARATOR
+    
+    attr_accessor :cvspath
+    attr_accessor :cvsmodule
+    
+    def initialize(io)
+      super(io)
+    end
+  
+    def parse_revisions
+      revisions = Revisions.new
+      while(log_entry = next_log_entry)
+        begin
+          parse_files(log_entry, revisions)
+        rescue Exception => e
+          $stderr.puts("could not parse log entry: #{log_entry}\ndue to: #{e.message}\n\t")
+          $stderr.puts(e.backtrace.join("\n\t"))
+        end
+      end
+      revisions.sort!
+      revisions
+    end
+    
+    def next_log_entry
+      read_until_matching_line(ENTRY_SEPARATOR)
+    end
+    
+    def split_entries(log_entry)
+      entries = [""]
+      log_entry.each_line do |line|
+        if line=~REVISION_SEPARATOR
+          entries << ""
+        else
+          entries[entries.length-1] << line
+        end
+      end
+      entries
+    end
+    
+    def parse_files(log_entry, revisions)
+      entries = split_entries(log_entry)
+
+      entries[1..entries.length].each do |entry|
+        file = parse_file(entry)
+        next if file.nil?
+        file.path = parse_path(entries[0])
+        file.status = RevisionFile::ADDED if file.native_revision_identifier =~ /1\.1$/
+        revisions.add(file)
+      end
+      nil
+    end
+    
+    def parse_head_revision(first_entry)
+      head_revision = extract_match(first_entry, /^head: (.*?)$/m)
+    end
+    
+    def parse_path(first_entry)
+      working_file = extract_match(first_entry, /^Working file: (.*?)$/m)
+      return convert_all_slashes_to_forward_slashes(working_file) unless working_file.nil? || working_file == ""
+      make_relative_to_module(extract_required_match(first_entry, /^RCS file: (.*?)(,v|$)/m))
+    end
+    
+    def make_relative_to_module(file)
+      return file if cvspath.nil? || cvsmodule.nil? || file.nil?
+      cvspath = convert_all_slashes_to_forward_slashes(self.cvspath)
+      convert_all_slashes_to_forward_slashes(file).gsub(/^#{cvspath}\/#{cvsmodule}\//, "")
+    end
+    
+    def parse_file(file_entry)
+      raise "can't parse: #{file_entry}" if file_entry =~ REVISION_SEPARATOR
+         
+      file_entry_lines = file_entry.split(/\r?\n/)
+
+      file = RevisionFile.new
+      file.native_revision_identifier =  extract_match(file_entry_lines[0], /revision (.*)$/)
+      file.previous_native_revision_identifier = determine_previous_native_revision_identifier(file.native_revision_identifier)
+
+      time = extract_required_match(file_entry_lines[1], /date: (.*?)(;|$)/)
+      if(time.strip.length == 19)
+        # CVS 1.11.x doesn't specify timezone (but assumes UTC), so we'll add it here.
+        time += " +0000"
+      end
+      file.time = Time.parse(time).utc
+      file.developer = extract_match(file_entry_lines[1], /author: (.*?);/)
+      
+      state = extract_match(file_entry_lines[1], /state: (.*?);/)
+      file.status = STATES[state]
+      
+      message_start = 2
+      branches = nil
+      if(file_entry_lines[2] =~ /^branches:\s+(.*);/)
+        message_start = 3
+        branches = $1
+      end
+
+      file.message = file_entry_lines[message_start..-1].join("\n")
+         
+      # Ignore the initial revision from import - we will have two of them
+      if(file.message == "Initial revision" && branches == "1.1.1")
+        return nil
+      end
+
+      file
+    end
+    
+    def determine_previous_native_revision_identifier(revision)
+      if revision =~ /(.*)\.(.*)/
+        big_version_number = $1
+        small_version_number = $2.to_i
+        if small_version_number == 1
+          nil
+        else
+          "#{big_version_number}.#{small_version_number - 1}"
+        end
+      else
+        nil
+      end
+    end
+    
+    def extract_required_match(string, regexp)
+      if(string =~ regexp)
+        return($1)
+      else
+        $stderr.puts("can't parse: '#{string}'\nexpected to match regexp: #{regexp.to_s}")
+      end
+    end
+    
+    def extract_match(string, regexp)
+      if string=~regexp
+        return($1)
+      else
+        ""
+      end
+    end
+    
+  private
+  
+    # The state field is "Exp" both for added and modified files. retards!
+    # We need some additional logic to figure out whether it is added or not.
+    # Maybe look at the revision. (1.1 means new I think. - deal with it later)
+    STATES = {"dead" => RevisionFile::DELETED, "Exp" => RevisionFile::MODIFIED} unless defined? STATES
+
+  end
+
+end

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

@@ -0,0 +1,120 @@
+require 'tempfile'
+require 'fileutils'
+require 'rscm'
+
+module RSCM
+  class Darcs < Base
+    # See http://progetti.arstecnica.it/tailor/browser/vcpx/darcs.py
+    attr_accessor :dir
+
+    def installed?
+      begin
+        darcs("--version", {}) 
+        true
+      rescue
+        false
+      end
+    end
+
+    def initialize(dir=".")
+      @dir = File.expand_path(dir)
+    end
+
+    def can_create_central?
+      true
+    end
+
+    def create_central
+      with_working_dir(@dir) do
+        darcs("initialize")
+      end
+    end
+    
+    def import_central(dir, message)
+      ENV["EMAIL"] = "dcontrol@codehaus.org"
+      FileUtils.cp_r(Dir.glob("#{dir}/*"), @dir)
+      with_working_dir(@dir) do
+        darcs("add --recursive .")
+        
+        logfile = Tempfile.new("darcs_logfile")
+        logfile.print("something nice\n")
+        logfile.print(message + "\n")
+        logfile.close
+        
+        darcs("record --all --logfile #{PathConverter.filepath_to_nativepath(logfile.path, false)}")
+      end
+    end
+
+    def commit(message)
+      logfile = Tempfile.new("darcs_logfile")
+      logfile.print("something nice\n")
+      logfile.print(message + "\n")
+      logfile.close
+
+      with_working_dir(@checkout_dir) do
+        darcs("record --all --logfile #{PathConverter.filepath_to_nativepath(logfile.path, false)}")
+      end
+    end
+
+    def add(relative_filename)
+      with_working_dir(@checkout_dir) do
+        darcs("add #{relative_filename}")
+      end
+    end
+
+    def checked_out?
+      File.exists?("#{@checkout_dir}/_darcs")
+    end
+
+    def uptodate?(from_identifier)
+      if (!checked_out?(@checkout_dir))
+        false
+      else
+        with_working_dir(@checkout_dir) do
+          darcs("pull --dry-run #{@dir}") do |io|
+            io.each_line do |line|
+              if (line =~ /No remote changes to pull in!/)
+                true
+              else
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def revisions(from_identifier, to_identifier=Time.infinity)
+      from_identifier = Time.epoch if from_identifier.nil?
+      to_identifier = Time.infinity if to_identifier.nil?
+      with_working_dir(@checkout_dir) do
+        darcs("changes --summary --xml-output") do |stdout|
+          DarcsLogParser.new.parse_revisions(stdout, from_identifier, to_identifier)
+        end
+      end
+    end
+  
+    def supports_trigger?
+      true
+    end
+
+  protected
+
+    def checkout_silent(to_identifier) # :yield: file
+      with_working_dir(File.dirname(checkout_dir)) do
+        darcs("get --repo-name #{File.basename(checkout_dir)} #{@dir}")
+      end
+    end
+
+    def ignore_paths
+      return [/_darcs/]
+    end
+
+  private
+
+    def darcs(darcs_cmd, options={}, &proc)
+      cmd = "darcs #{darcs_cmd}"
+      execute(cmd, options, &proc)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'rscm'
+require 'time'
+require 'stringio'
+require 'rexml/document'
+
+module RSCM
+  class DarcsLogParser
+    def parse_revisions(io, from_identifier=Time.epoch, to_identifier=Time.infinity)
+      revisions = Revisions.new
+
+      doc = REXML::Document.new(io)
+
+      path_revisions = {}
+      doc.elements.each("//patch") do |element|
+        revision = parse_revision(element.to_s, path_revisions)
+        if ((from_identifier <= revision.time) && (revision.time <= to_identifier))
+          revisions.add(revision)
+        end
+      end
+
+      revisions.each do |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
+
+      revisions
+    end
+
+    def parse_revision(revision_io, path_revisions)
+      revision = Revision.new
+
+      doc = REXML::Document.new(revision_io)
+
+      doc.elements.each("patch") do |element|
+        revision.identifier =  element.attributes['hash']
+        revision.developer = element.attributes['author']
+        revision.time = Time.parse(element.attributes['local_date'])
+        revision.message = element.elements["comment"].text
+        revision.message.lstrip!
+        revision.message.rstrip!
+
+        element.elements["summary"].elements.each("add_file") do |file|
+          add_changes(revision, file.text.strip, RevisionFile::ADDED, path_revisions)
+        end
+        element.elements["summary"].elements.each("modify_file") do |file|
+          add_changes(revision, file.text.strip, RevisionFile::MODIFIED, path_revisions)
+        end
+      end
+
+      revision
+    end
+
+  private
+
+    def add_changes(revision, path, state, path_revisions)
+      revision << RevisionFile.new(path, state, revision.developer, nil, revision.identifier, revision.time)
+
+      path_revisions[path] ||= []
+      path_revisions[path] << revision.identifier
+    end
+  end
+end
+

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

@@ -0,0 +1,338 @@
+require 'rscm/line_editor'
+require 'fileutils'
+require 'rscm'
+
+module RSCM
+  class Monotone < Base
+    attr_accessor :db_file
+    attr_accessor :branch
+    attr_accessor :key
+    attr_accessor :passphrase
+    attr_accessor :keys_file
+    attr_accessor :server
+
+    def initialize(branch=nil, key=nil, passphrase=nil, keys_file=nil, server=nil, central_checkout_dir=nil)
+      @branch = branch
+      @key = key
+      @passphrase = passphrase
+      @keys_file = keys_file
+      @server = server
+      @central_checkout_dir = File.expand_path(central_checkout_dir) unless central_checkout_dir.nil?
+    end
+
+    def add(relative_filename)
+      db = db(@checkout_dir)
+      with_working_dir(@checkout_dir) do
+        monotone("add #{relative_filename}", db)
+      end
+    end
+
+    def move(relative_src, relative_dest)
+      with_working_dir(@checkout_dir) do
+        monotone("rename #{relative_src} #{relative_dest}", db)
+        FileUtils.mv(relative_src, relative_dest)
+      end
+    end
+
+    def can_create_central?
+      @server == "localhost" && !@central_checkout_dir.nil?
+    end
+    
+    def central_exists?
+      @central_checkout_dir && @serve_pid
+    end
+
+    def create_central
+      init(@central_checkout_dir)
+      # create empty working copy
+      dir = PathConverter.filepath_to_nativepath(@central_checkout_dir, false)
+      # set up a working copy
+      monotone("setup #{dir}")
+      start_serve
+    end
+    
+    def start_serve
+      mode = File::CREAT|File::WRONLY
+      if File.exist?(rcfile)
+        mode = File::APPEND|File::WRONLY
+      end
+
+      begin
+        File.open(rcfile, mode) do |file|
+          file.puts("function get_netsync_anonymous_read_permitted(collection)")
+          file.puts("  return true")
+          file.puts("end")
+        end
+      rescue => e
+        puts e.message
+        puts e.backtrace.join("\n")
+        raise "Didn't have permission to write to #{rcfile}."
+      end
+
+      @serve_pid = fork do
+        #Signal.trap("HUP") { puts "Monotone server shutting down..."; exit }
+        monotone("serve --rcfile=\"#{rcfile}\" #{@server} #{@branch}", db(@central_checkout_dir)) do |io|
+          puts "PASSPHRASE: #{@passphrase}"
+          io.puts(@passphrase)
+          io.close_write
+        end
+      end
+      Process.detach(@serve_pid)
+    end
+    
+    def stop_serve
+      Process.kill("HUP", @serve_pid) if @serve_pid
+      Process.waitpid2(@serve_pid) if @serve_pid
+      @serve_pid = nil
+    end
+    
+    def destroy_central
+      stop_serve
+      FileUtils.rm_rf(@central_checkout_dir) if File.exist?(@central_checkout_dir)
+      FileUtils.rm(db(@central_checkout_dir)) if File.exist?(db(@central_checkout_dir))
+      puts "Destroyed Monotone server"
+    end
+    
+    def transactional?
+      true
+    end
+
+    def import_central(dir, message)
+      FileUtils.cp_r(Dir["#{dir}/*"], @central_checkout_dir)
+      with_working_dir(@central_checkout_dir) do
+        monotone("add .")
+        commit_in_dir(message, @central_checkout_dir)
+      end
+    end
+
+    def checked_out?
+      mt = File.expand_path("#{@checkout_dir}/MT")
+      File.exists?(mt)
+    end
+
+    def uptodate?(identifier=nil)
+      if (!checked_out?)
+        false
+      else
+        pull
+
+        rev = identifier ? identifier : head_revision
+        local_revision == rev
+      end
+    end
+
+    def revisions(from_identifier, to_identifier=Time.infinity)
+      checkout(to_identifier)
+      to_identifier = Time.infinity if to_identifier.nil?
+      with_working_dir(checkout_dir) do
+        monotone("log") do |stdout|
+          MonotoneLogParser.new.parse_revisions(stdout, from_identifier, to_identifier)
+        end
+      end
+    end
+
+    def commit(message)
+      commit_in_dir(message, @checkout_dir)
+      with_working_dir(@checkout_dir) do
+        monotone("push #{@server} #{@branch}") do |io|
+          io.puts(@passphrase)
+          io.close_write
+          io.read
+        end
+      end
+    end
+
+    def supports_trigger?
+      true
+    end
+
+    def trigger_mechanism
+      "MT/monotonerc"
+    end
+
+    # http://www.venge.net/monotone/monotone.html#Hook-Reference
+    def install_trigger(trigger_command, install_dir)
+      stop_serve
+      if (WINDOWS)
+        install_win_trigger(trigger_comand, install_dir)
+      else
+        install_unix_trigger(trigger_command, install_dir)
+      end
+      start_serve
+    end
+    
+    def trigger_installed?(trigger_command, install_dir)
+      File.exist?(rcfile)
+    end
+
+    def uninstall_trigger(trigger_command, install_dir)
+      stop_serve
+      File.delete(rcfile)
+      start_serve
+    end
+
+    def diff(change, &block)
+      checkout(change.revision)
+      with_working_dir(@checkout_dir) do
+        monotone("diff --revision=#{change.previous_native_revision_identifier} #{change.path}") do |stdout|
+          yield stdout
+        end
+      end
+    end
+    
+  protected
+
+    # Checks out silently. Called by superclass' checkout.
+    def checkout_silent(to_identifier)
+      # raise "Monotone doesn't support checkout to time. Please use identifiers instead." if to_identifier.is_a?(Time)
+      db_file = db(@checkout_dir)
+      if(!File.exist?(db_file))
+        init(@checkout_dir)
+      end
+
+      pull
+      checked_out = checked_out?
+
+      with_working_dir(@checkout_dir) do
+        monotone("checkout .", db_file, @branch) unless checked_out
+
+        selector = expand_selector(to_identifier)
+        monotone("update #{selector}", db_file)
+      end
+    end
+
+    # Administrative files that should be ignored when counting files.
+    def ignore_paths
+      [/MT/, /\.mt-attrs/]
+    end
+
+  private
+
+    def commit_in_dir(message, dir)
+      db_file = db(dir)
+      with_working_dir(dir) do
+        monotone("commit --message='#{message}'", db_file, @branch, @key) do |io|
+          io.puts(@passphrase)
+          io.close_write
+          io.read
+        end
+      end
+    end
+
+    def pull
+      db_file = db(@checkout_dir)
+      with_working_dir(@checkout_dir) do
+        # pull from the "central" server
+        if(@server)
+          monotone("pull #{@server} #{@branch}", db_file) do |io|
+            io.puts(@passphrase)
+            io.close_write
+            io.read
+          end
+        end
+      end
+    end
+
+    def db(checkout_dir)
+      PathConverter.filepath_to_nativepath(checkout_dir + ".db", false)
+    end
+
+    # Initialises a monotone database
+    #
+    def init(dir)
+      dir = File.expand_path(dir)
+      db_file = db(dir)
+      raise "Database #{db_file} already exists" if File.exist?(db_file)
+      FileUtils.mkdir_p(File.dirname(db_file))
+      # create database
+      monotone("db init", db_file)
+      # TODO: do a genkey
+      monotone("read", db_file) do |io|
+        io.write(File.open(@keys_file).read)
+        io.close_write
+      end
+    end
+
+    def install_unix_trigger(trigger_command, install_dir)
+      mode = File::CREAT|File::WRONLY
+      if File.exist?(rcfile)
+        mode = File::APPEND|File::WRONLY
+      end
+
+      begin
+        File.open(rcfile, mode) do |file|
+          file.puts("function note_commit(new_id, certs)")
+          execstr = "\"" + trigger_command.split.join("\",\"") + "\""
+          file.puts("  execute(#{execstr})")
+          file.puts("end")
+        end
+      rescue => e
+        puts e.message
+        puts e.backtrace.join("\n")
+        raise "Didn't have permission to write to #{rcfile}."
+      end
+      
+      # push to the "central" server
+#      monotone("push #{@server} #{@branch}", db(@central_checkout_dir))
+    end
+
+    def rcfile
+      "#{@central_checkout_dir}/MT/monotonerc"
+    end
+
+    def local_revision
+      local_revision = nil
+      rev_file = File.expand_path("#{checkout_dir}/MT/revision")
+      local_revision = File.open(rev_file).read.strip
+      local_revision
+    end
+    
+    def head_revision
+      # FIXME: this will grab last head if heads are not merged.
+      head_revision = nil
+      monotone("heads", db(@checkout_dir), @branch) do |stdout|
+        stdout.each_line do |line|
+          next if (line =~ /^monotone:/)
+          head_revision = line.split(" ")[0]
+        end
+      end
+      head_revision
+    end
+
+    # See http://www.venge.net/monotone/monotone.html#Selectors
+    # Also see docs for expand_selector in the same document
+    # Dates are formatted with strftime-style %F, which is of style 2005-28-02,
+    # which is very coarse grained. Date identifiers are therefore discouraged.
+    def expand_selector(identifier)
+      if(identifier.is_a?(Time))
+        # Won't work:
+        # "d:#{identifier.strftime('%Y-%m-%d')}"
+        ""
+      else
+        "i:#{identifier}"
+      end
+    end
+  
+    def monotone(monotone_cmd, db_file=nil, branch=nil, key=nil)
+      db_opt = db_file ? "--db=\"#{db_file}\"" : ""
+      branch_opt = branch ? "--branch=\"#{branch}\"" : ""
+      key_opt = key ? "--key=\"#{key}\"" : ""
+      rcfile_opt = @rcfile ? "--rcfile=\"#{@rcfile}\"" : ""
+      cmd = "monotone #{db_opt} #{branch_opt} #{key_opt} #{rcfile_opt} #{monotone_cmd}"
+      Better.popen(cmd, "r+") do |io|
+        if(block_given?)
+          return(yield(io))
+        else
+          # just read stdout so we can exit
+          io.read
+        end
+      end
+    end
+
+    def monotone_date(time)
+      return nil unless time
+      time.utc.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+    
+  end
+end