rscm 0.2.1.1404 → 0.3.0

data/lib/rscm/scm/cvs_log_parser.rb

@@ -1,4 +1,4 @@
-require 'rscm/changes'
+require 'rscm/revision'
 require 'rscm/abstract_log_parser'
 
 require 'ftools'
@@ -17,19 +17,19 @@ module RSCM
       @log = ""
     end
   
-    def parse_changesets
-      changesets = ChangeSets.new
+    def parse_revisions
+      revisions = Revisions.new
       while(log_entry = next_log_entry)
         @log<<log_entry
         @log<<""
         begin
-          parse_changes(log_entry, changesets)
+          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
-      changesets.sort!
+      revisions.sort!
     end
     
     def next_log_entry
@@ -48,20 +48,20 @@ module RSCM
       entries
     end
     
-    def parse_changes(log_entry, changesets)
+    def parse_files(log_entry, revisions)
       entries = split_entries(log_entry)
 
       entries[1..entries.length].each do |entry|
-        change = parse_change(entry)
-        next if change.nil?
-        change.path = parse_path(entries[0])
+        file = parse_file(entry)
+        next if file.nil?
+        file.path = parse_path(entries[0])
 
-        change.status = Change::ADDED if change.revision =~ /1\.1$/
+        file.status = RevisionFile::ADDED if file.native_revision_identifier =~ /1\.1$/
 
-        changeset = changesets.add(change)
-        # CVS doesn't have revision for changesets, use
+        revision = revisions.add(file)
+        # CVS doesn't have revision for revisions, use
         # Fisheye-style revision
-#        changeset.revision = "MAIN:#{change.developer}:#{change.time.utc.strftime('%Y%m%d%H%M%S')}" if changeset
+#        revision.native_revision_identifier =  "MAIN:#{file.developer}:#{file.time.utc.strftime('%Y%m%d%H%M%S')}" if revision
       end
       nil
     end
@@ -82,39 +82,39 @@ module RSCM
       convert_all_slashes_to_forward_slashes(file).gsub(/^#{cvspath}\/#{cvsmodule}\//, "")
     end
     
-    def parse_change(change_entry)
-      raise "can't parse: #{change_entry}" if change_entry =~ REVISION_SEPARATOR
+    def parse_file(file_entry)
+      raise "can't parse: #{file_entry}" if file_entry =~ REVISION_SEPARATOR
          
-      change_entry_lines = change_entry.split(/\r?\n/)
-      change = Change.new
+      file_entry_lines = file_entry.split(/\r?\n/)
+      file = RevisionFile.new
 
-      change.revision = extract_match(change_entry_lines[0], /revision (.*)$/)
+      file.native_revision_identifier =  extract_match(file_entry_lines[0], /revision (.*)$/)
       
-      change.previous_revision = determine_previous_revision(change.revision)
-      change.time = parse_cvs_time(extract_required_match(change_entry_lines[1], /date: (.*?)(;|$)/))
-      change.developer = extract_match(change_entry_lines[1], /author: (.*?);/)
+      file.previous_native_revision_identifier = determine_previous_native_revision_identifier(file.native_revision_identifier)
+      file.time = parse_cvs_time(extract_required_match(file_entry_lines[1], /date: (.*?)(;|$)/))
+      file.developer = extract_match(file_entry_lines[1], /author: (.*?);/)
       
-      state = extract_match(change_entry_lines[1], /state: (.*?);/)
-      change.status = STATES[state]
+      state = extract_match(file_entry_lines[1], /state: (.*?);/)
+      file.status = STATES[state]
       
       message_start = 2
       branches = nil
-      if(change_entry_lines[2] =~ /^branches:\s+(.*);/)
+      if(file_entry_lines[2] =~ /^branches:\s+(.*);/)
         message_start = 3
         branches = $1
       end
 
-      change.message = change_entry_lines[message_start..-1].join("\n")
+      file.message = file_entry_lines[message_start..-1].join("\n")
          
       # Ignore the initial revision from import - we will have two of them
-      if(change.message == "Initial revision" && branches == "1.1.1")
+      if(file.message == "Initial revision" && branches == "1.1.1")
         return nil
       end
 
-      change
+      file
     end
     
-    def determine_previous_revision(revision)
+    def determine_previous_native_revision_identifier(revision)
       if revision =~ /(.*)\.(.*)/
         big_version_number = $1
         small_version_number = $2.to_i
@@ -154,7 +154,7 @@ module RSCM
     # 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" => Change::DELETED, "Exp" => Change::MODIFIED} unless defined? STATES
+    STATES = {"dead" => RevisionFile::DELETED, "Exp" => RevisionFile::MODIFIED} unless defined? STATES
 
   end
 

data/lib/rscm/scm/darcs.rb

@@ -3,8 +3,8 @@ require 'fileutils'
 require 'rscm'
 
 module RSCM
-  class Darcs < AbstractSCM
-    register self
+  class Darcs < Base
+    #register self
 
     ann :description => "Directory"
     attr_accessor :dir
@@ -17,56 +17,104 @@ module RSCM
       "Darcs"
     end
 
-    def create
+    def can_create_central?
+      true
+    end
+
+    def create_central
       with_working_dir(@dir) do
-        IO.popen("darcs initialize") do |stdout|
-          stdout.each_line do |line|
-            yield line if block_given?
-          end
-        end
+        darcs("initialize")
       end
     end
     
-    def import(dir, message)
+    def import_central(dir, message)
       ENV["EMAIL"] = "dcontrol@codehaus.org"
       FileUtils.cp_r(Dir.glob("#{dir}/*"), @dir)
       with_working_dir(@dir) do
-puts "IN::::: #{@dir}"
-        cmd = "darcs add --recursive ."
-puts cmd
-        IO.popen(cmd) do |stdout|
-          stdout.each_line do |line|
-            yield line if block_given?
-          end
-        end
-puts $?
+        darcs("add --recursive .")
+        
         logfile = Tempfile.new("darcs_logfile")
-        logfile.print(message)
+        logfile.print("something nice\n")
+        logfile.print(message + "\n")
         logfile.close
         
-        cmd = "darcs record --all --patch-name \"something nice\" --logfile #{PathConverter.filepath_to_nativepath(logfile.path, false)}"
-puts cmd
-        IO.popen(cmd) do |stdout|
-          stdout.each_line do |line|
-            yield line if block_given?
+        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
-puts $?
       end
     end
 
-    def checkout(checkout_dir) # :yield: file
+    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
+  
+  protected
+
+    def checkout_silent(to_identifier) # :yield: file
       with_working_dir(File.dirname(checkout_dir)) do
-cmd = "darcs get --verbose --repo-name #{File.basename(checkout_dir)} #{@dir}"
-puts cmd
-        IO.popen(cmd) do |stdout|
-          stdout.each_line do |line|
-puts line
-            yield line if block_given?
-          end
+        darcs("get --repo-name #{File.basename(checkout_dir)} #{@dir}")
+      end
+    end
+
+    def ignore_paths
+      return [/_darcs/]
+    end
+
+  private
+
+    def darcs(darcs_cmd)
+      cmd = "darcs #{darcs_cmd}"
+
+      Better.popen(cmd, "r+") do |io|
+        if(block_given?)
+          return(yield(io))
+        else
+          io.read
         end
       end
-puts $?
     end
   end
 end

data/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/lib/rscm/scm/monotone.rb

@@ -1,8 +1,9 @@
+require 'rscm/line_editor'
 require 'fileutils'
 require 'rscm'
 
 module RSCM
-  class Monotone < AbstractSCM
+  class Monotone < Base
     register self
 
     ann :description => "Database file"
@@ -20,101 +21,130 @@ module RSCM
     ann :description => "Keys file"
     attr_accessor :keys_file
 
-    def initialize(db_file="MT.db", branch="", key="", passphrase="", keys_file="")
-      @db_file = File.expand_path(db_file)
+    ann :description => "Server"
+    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 name
       "Monotone"
     end
 
-    def add(checkout_dir, relative_filename)
-      with_working_dir(checkout_dir) do
-        monotone("add #{relative_filename}")
+    def add(relative_filename)
+      db = db(@checkout_dir)
+      with_working_dir(@checkout_dir) do
+        monotone("add #{relative_filename}", db)
       end
     end
 
-    def create
-      FileUtils.mkdir_p(File.dirname(@db_file))
-      monotone("db init")
-      monotone("read") do |io|
-        io.write(File.open(@keys_file).read)
-        io.close_write
-      end
+    def can_create_central?
+      @server == "localhost" && !@central_checkout_dir.nil?
     end
-
-    def transactional?
-      true
+    
+    def central_exists?
+      @central_checkout_dir && @serve_pid
     end
 
-    def import(dir, message)
-      dir = File.expand_path(dir)
-
-      # post 0.17, this can be "cd dir && cmd add ."
+    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
 
-      files = Dir["#{dir}/*"]
-      relative_paths_to_add = to_relative(dir, files)
+      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
 
-      with_working_dir(dir) do
-        monotone("add #{relative_paths_to_add.join(' ')}")
-        monotone("commit '#{message}'", @branch, @key) do |io|
+      @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
-          io.read
         end
       end
+      Process.detach(@serve_pid)
     end
-
-    def checked_out?(checkout_dir)
-      File.exists?("#{checkout_dir}/MT")
+    
+    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 uptodate?(checkout_dir, from_identifier)
-      if (!checked_out?(checkout_dir))
-        false
-      else
-        lr = local_revision(checkout_dir)
-        hr = head_revision(checkout_dir)
-        lr == hr
+    def import_central(dir, message)
+      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 local_revision(checkout_dir)
-      local_revision = nil
-      rev_file = File.expand_path("#{checkout_dir}/MT/revision")
-      local_revision = File.open(rev_file).read.strip
-      local_revision
+    def checked_out?
+      mt = File.expand_path("#{@checkout_dir}/MT")
+      File.exists?(mt)
     end
-    
-    def head_revision(checkout_dir)
-      # FIXME: this will grab last head if heads are not merged.
-      head_revision = nil
-      monotone("heads", @branch) do |stdout|
-        stdout.each_line do |line|
-          next if (line =~ /^monotone:/)
-          head_revision = line.split(" ")[0]
-        end
+
+    def uptodate?(identifier=nil)
+      if (!checked_out?)
+        false
+      else
+        pull
+
+        rev = identifier ? identifier : head_revision
+        local_revision == rev
       end
-      head_revision
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
-      from_identifier = Time.epoch if from_identifier.nil?
+    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", @branch, @key) do |stdout|
-          MonotoneLogParser.new.parse_changesets(stdout, from_identifier, to_identifier)
+        monotone("log") do |stdout|
+          MonotoneLogParser.new.parse_revisions(stdout, from_identifier, to_identifier)
         end
       end
     end
 
-    def commit(checkout_dir, message)
-      with_working_dir(checkout_dir) do
-        monotone("commit '#{message}'", @branch, @key) do |io|
+    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
@@ -122,24 +152,54 @@ module RSCM
       end
     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(checkout_dir, to_identifier)
-      checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
-      if checked_out?(checkout_dir)
-        with_working_dir(checkout_dir) do
-          monotone("update")
-        end
-      else
-        monotone("checkout #{checkout_dir}", @branch, @key) do |stdout|
-          stdout.each_line do |line|
-            # TODO: checkout prints nothing to stdout - may be fixed in a future monotone.
-            # When/if it happens we may want to do a kosher implementation of checkout
-            # to get yields as checkouts happen.
-            yield line if block_given?
-          end
-        end
+    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
 
@@ -149,12 +209,119 @@ module RSCM
     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, branch=nil, key=nil)
+    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}\"" : ""
-      cmd = "monotone --db=\"#{@db_file}\" #{branch_opt} #{key_opt} #{monotone_cmd}"
-      safer_popen(cmd, "r+") do |io|
+      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
@@ -163,6 +330,11 @@ module RSCM
         end
       end
     end
-  
+
+    def monotone_date(time)
+      return nil unless time
+      time.utc.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+    
   end
 end