rscm 0.2.1.1404 → 0.3.0

data/lib/rscm/scm/monotone_log_parser.rb

@@ -6,49 +6,56 @@ module RSCM
 
   class MonotoneLogParser
   
-    def parse_changesets(io, from_identifier=Time.epoch, to_identifier=Time.infinity)
+    def parse_revisions(io, from_identifier=Time.epoch, to_identifier=Time.infinity)
       # skip first separator
       io.readline
       
-      changesets = ChangeSets.new
-      changeset_string = ""
+      all_revisions = []
+      revision_string = ""
       
       # hash of path => [array of revisions]
       path_revisions = {}
       io.each_line do |line|
         if(line =~ /-----------------------------------------------------------------/)
-          changeset = parse_changeset(StringIO.new(changeset_string), path_revisions)
-          changesets.add(changeset)
-          changeset_string = ""
+          revision = parse_revision(StringIO.new(revision_string), path_revisions)
+          all_revisions << revision
+          revision_string = ""
         else
-          changeset_string << line
+          revision_string << line
         end
       end
-      changeset = parse_changeset(StringIO.new(changeset_string), path_revisions)
-      if((from_identifier <= changeset.time) && (changeset.time <= to_identifier))
-        changesets.add(changeset)
-      end
-
-      # set the previous revisions. most recent is at index 0.
-      changesets.each do |changeset|
-        changeset.each do |change|
-          current_index = path_revisions[change.path].index(change.revision)
-          change.previous_revision = path_revisions[change.path][current_index + 1]
+      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
-      changesets
-    end
-
-    def parse_changeset(changeset_io, path_revisions)
-      changeset = ChangeSet.new
+      revisions
+    end
+    
+    def parse_revision(revision_io, path_revisions)
+      revision = Revision.new
       state = nil
-      changeset_io.each_line do |line|
-        if(line =~ /^Revision: (.*)$/ && changeset.revision.nil?)
-          changeset.revision = $1
-        elsif(line =~ /^Author: (.*)$/ && changeset.developer.nil?)
-          changeset.developer = $1
-        elsif(line =~ /^Date: (.*)$/ && changeset.time.nil?)
-          changeset.time = Time.utc(
+      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,
@@ -56,37 +63,44 @@ module RSCM
             $1[14..15].to_i,
             $1[17..18].to_i
           )
-        elsif(line =~ /^ChangeLog:$/ && changeset.message.nil?)
+        elsif(line =~ /^ChangeLog:\s*$/ && revision.message.nil?)
           state = :message
-        elsif(state == :message && changeset.message.nil?)
-          changeset.message = ""
-        elsif(state == :message && changeset.message)
-          changeset.message << line
-        elsif(line =~ /^Added files:$/)
+        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(changeset, line, Change::ADDED, path_revisions)
-        elsif(line =~ /^Modified files:$/)
+          add_changes(revision, line, RevisionFile::ADDED, path_revisions)
+        elsif(line =~ /^Modified files:\s*$/)
           state = :modified
         elsif(state == :modified)
-          add_changes(changeset, line, Change::MODIFIED, path_revisions)
+          add_changes(revision, line, RevisionFile::MODIFIED, path_revisions)
         end
       end
-      changeset.message.chomp!
-      changeset
+      revision.message.chomp! rescue revision.message = ''
+      revision
     end
     
   private
 
-    def add_changes(changeset, line, state, path_revisions)
+    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|
-        changeset << Change.new(path, state, changeset.developer, nil, changeset.revision, changeset.time)
+        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] << changeset.revision
+        path_revisions[path] << revision.identifier
       end
       
     end

data/lib/rscm/scm/mooky.rb

@@ -1,8 +1,8 @@
-require 'rscm/abstract_scm'
+require 'rscm/base'
 
 module RSCM
-  class Mooky < AbstractSCM
-    register self
+  class Mooky < Base
+    #register self
 
     ann :description => "The Foo", :tip => "Foo is nonsense"
     attr_accessor :foo

data/lib/rscm/scm/perforce.rb

@@ -1,4 +1,4 @@
-require 'rscm/abstract_scm'
+require 'rscm/base'
 require 'rscm/path_converter'
 require 'rscm/line_editor'
 
@@ -9,26 +9,64 @@ require 'parsedate'
 require 'stringio'
 
 module RSCM
-  # RSCM implementation for Perforce.
+  # Perforce RSCM implementation.
   #
   # Understands operations against multiple client-workspaces
   # You need the p4/p4d executable on the PATH in order for it to work.
   #
-  class Perforce < AbstractSCM
+  class Perforce < Base
     register self
 
     include FileUtils
 
-    ann :description => "Depot path", :tip => "The path to the Perforce depot"
-    attr_accessor :depotpath
+    @@counter = 0
+
+    ann :description => "P4CLIENT: workspace name"
+    attr_accessor :client_name
+
+    ann :description => "P4PORT: [host:port]", :tip => "perforce server address e.g. 10.12.1.55:1666"
+    attr_accessor :port
+
+    ann :description => "P4USER", :tip => "username"
+    attr_accessor :user
+
+    ann :description => "P4PASSWD", :tip => "password"
+    attr_accessor :pwd
+
+    attr_accessor :repository_root_dir
 
-    def initialize(repository_root_dir = "")
-      @clients = {}
-      @depotpath = repository_root_dir
+    def initialize(port = "1666", user = ENV["LOGNAME"], pwd = "", client_name = Perforce.next_client_name)
+      @port, @user, @pwd, @client_name = port, user, pwd, client_name
     end
 
-    def create
-      P4Daemon.new(@depotpath).start
+    def p4admin
+      @p4admin ||= P4Admin.new(@port, @user, @pwd)
+    end
+
+    def p4client
+      @p4client ||= p4admin.create_client(@checkout_dir, @client_name)
+    end
+
+    def can_create_central?
+      true
+    end
+    
+    def create_central
+      raise "perforce depot can be created only from tests" unless @repository_root_dir
+      @p4d = P4Daemon.new(@repository_root_dir)
+      @p4d.start
+    end
+
+    def destroy_central
+      @p4d.shutdown
+    end
+
+    def central_exists?
+      p4admin.central_exists?
+    end
+
+    def can_create_central?
+      true
     end
 
     def name
@@ -39,35 +77,35 @@ module RSCM
       true
     end
 
-    def import(dir, comment)
+    def import_central(dir, comment)
       with_create_client(dir) do |client|
         client.add_all(list_files)
         client.submit(comment)
       end
     end
 
-    def checkout(checkout_dir, to_identifier = nil, &proc)
-      client(checkout_dir).checkout(to_identifier, &proc)
+    def checkout(to_identifier = nil, &proc)
+      p4client.checkout(to_identifier, &proc)
     end
 
-    def add(checkout_dir, relative_filename)
-      client(checkout_dir).add(relative_filename)
+    def add(relative_filename)
+      p4client.add(relative_filename)
     end
 
-    def commit(checkout_dir, message, &proc)
-      client(checkout_dir).submit(message, &proc)
+    def commit(message, &proc)
+      p4client.submit(message, &proc)
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
-      client(checkout_dir).changesets(from_identifier, to_identifier)
+    def revisions(from_identifier, to_identifier=Time.infinity)
+      p4client.revisions(from_identifier, to_identifier)
     end
 
-    def uptodate?(checkout_dir, from_identifier)
-      client(checkout_dir).uptodate?
+    def uptodate?(from_identifier)
+      p4client.uptodate?
     end
 
     def edit(file)
-      client_containing(file).edit(file)
+      p4client.edit(file)
     end
 
     def trigger_installed?(trigger_command, trigger_files_checkout_dir)
@@ -82,25 +120,18 @@ module RSCM
       p4admin.uninstall_trigger(trigger_command)
     end
 
-  private
-
-    def p4admin
-      @p4admin ||= P4Admin.new
+    def diff(revfile, &proc)
+      p4client.diff(revfile, &proc)
     end
 
-    def client_containing(path)
-      @clients.values.find {|client| client.contains?(path)}
-    end
-
-    def client(rootdir)
-      @clients[rootdir] ||= create_client(rootdir)
-    end
+  private
 
     def with_create_client(rootdir)
       raise "needs a block" unless block_given?
       rootdir = File.expand_path(rootdir)
       with_working_dir(rootdir) do
-        client = create_client(rootdir)
+        mkdir_p(rootdir)
+        client = p4admin.create_client(rootdir, Perforce.next_client_name)
         begin
           yield client
         ensure
@@ -109,70 +140,43 @@ module RSCM
       end
     end
 
-    def delete_client(client)
-      p4admin.delete_client(client.name)
+    def self.next_client_name
+      "temp_client_#{@@counter += 1}"
     end
 
-    def create_client(rootdir)
-      rootdir = File.expand_path(rootdir) if rootdir =~ /\.\./
-      mkdir_p(rootdir)
-      p4admin.create_client(rootdir)
+    def delete_client(client)
+      p4admin.delete_client(client)
     end
 
     def list_files
       files = Dir["**/*"].delete_if{|f| File.directory?(f)}
       files.collect{|f| File.expand_path(f)}
     end
+  end
 
-    class P4Daemon
-      include FileUtils
-
-      def initialize(depotpath)
-        @depotpath = depotpath
-      end
-
-      def start
-        shutdown if running?
-        launch
-        assert_running
-      end
-
-      def assert_running
-        raise "p4d did not start properly" if timeout(10) { running? }
-      end
-
-      def launch
-        fork do
-          mkdir_p(@depotpath)
-          cd(@depotpath)
-          debug "starting p4 server"
-          exec("p4d")
-        end
-        at_exit { shutdown }
-      end
+  # Understands p4 administrative operations (not specific to a client)
+  class P4Admin
 
-      def shutdown
-        `p4 -p 1666 admin stop`
-      end
+    def initialize(port, user, pwd)
+      @port, @user, @pwd = port, user, pwd
+    end
 
-      def running?
-        !`p4 -p 1666 info`.empty?
+    def create_client(rootdir, clientname)
+      rootdir = File.expand_path(rootdir) if rootdir =~ /\.\./
+      unless client_exists?(rootdir, clientname)
+        execute_popen("client -i", "w+", clientspec(clientname, rootdir))
       end
+      P4Client.new(rootdir, clientname, @port, @user, @pwd)
     end
-  end
-
-  # Understands p4 administrative operations (not specific to a client)
-  class P4Admin
-    @@counter = 0
 
-    def create_client(rootdir)
-      name = next_name
-      popen("client -i", "w+", clientspec(name, rootdir))
-      P4Client.new(name, rootdir)
+    def client_exists?(rootdir, clientname)
+      dir_regex = Regexp.new(rootdir)
+      name_regex = Regexp.new(clientname)
+      execute("clients").split("\n").find {|c| c =~ dir_regex && c =~ name_regex}
     end
 
-    def delete_client(name)
-      execute("client -d #{name}")
+    def delete_client(client)
+      execute("client -d #{client.name}")
     end
 
     def trigger_installed?(trigger_command)
@@ -180,22 +184,26 @@ module RSCM
     end
 
     def install_trigger(trigger_command)
-      popen("triggers -i", "a+", triggerspec_with(trigger_command))
+      execute_popen("triggers -i", "a+", triggerspec_append(trigger_command))
     end
 
     def uninstall_trigger(trigger_command)
-      popen("triggers -i", "a+", triggerspec_without(trigger_command))
+      execute_popen("triggers -i", "a+", triggerspec_remove(trigger_command))
     end
 
-    def triggerspec_with(trigger_command)
+    def triggerspec_append(trigger_command)
       new_trigger = " damagecontrol commit //depot/... \"#{trigger_command}\" "
       triggers + $/ + new_trigger
     end
 
-    def triggerspec_without(trigger_command)
+    def triggerspec_remove(trigger_command)
       triggers.reject {|line| line =~ /#{trigger_command}/}.join
     end
 
+    def central_exists?
+      execute("info").split.join(" ") !~ /Connect to server failed/
+    end
+
     def clientspec(name, rootdir)
       s = StringIO.new
       s.puts "Client: #{name}"
@@ -213,8 +221,8 @@ module RSCM
       execute("triggers -o")
     end
 
-    def popen(cmd, mode, input)
-      IO.popen("p4 -p 1666 #{cmd}", mode) do |io|
+    def execute_popen(cmd, mode, input)
+      IO.popen(format_cmd(cmd), mode) do |io|
         io.puts(input)
         io.close_write
         io.each_line {|line| debug(line)}
@@ -222,41 +230,38 @@ module RSCM
     end
 
     def execute(cmd)
-      cmd = "p4 -p 1666 #{cmd}"
-      puts "> executing: #{cmd}"
+      cmd = format_cmd(cmd)
+      $stderr.puts "> executing: #{cmd}"
       `#{cmd}`
     end
 
-    def next_name
-      "client#{@@counter += 1}"
+    def format_cmd(cmd)
+      "p4 -p #{@port} -u '#{@user}' -P '#{@pwd}' #{cmd} 2>&1"
     end
   end
 
   # Understands operations against a client-workspace
   class P4Client
     DATE_FORMAT = "%Y/%m/%d:%H:%M:%S"
-    STATUS = { "add" => Change::ADDED, "edit" => Change::MODIFIED, "delete" => Change::DELETED }
-    PERFORCE_EPOCH = Time.utc(1970, 1, 1, 6, 0, 1)  #perforce doesn't like Time.utc(1970)
-
-    attr_accessor :name, :rootdir
-
-    def initialize(name, rootdir)
-      @name = name
-      @rootdir = rootdir
-    end
+    STATUS = { "add" => RevisionFile::ADDED, "edit" => RevisionFile::MODIFIED, "delete" => RevisionFile::DELETED }
 
-    def contains?(file)
-      file = File.expand_path(file)
-      file =~ /^#{@rootdir}/
+    def initialize(checkout_dir, name, port, user, pwd)
+      @checkout_dir, @name, @port, @user, @pwd = checkout_dir, name, port, user, pwd
     end
 
     def uptodate?
       p4("sync -n").empty?
     end
 
-    def changesets(from_identifier, to_identifier)
-      changesets = changelists(from_identifier, to_identifier).collect {|changelist| to_changeset(changelist)}
-      ChangeSets.new(changesets)
+    def revisions(from_identifier, to_identifier)
+      revisions = changelists(from_identifier, to_identifier).collect {|changelist| to_revision(changelist)}
+      # We have to reverse the revisions in order to make them appear in chronological order,
+      # P4 lists the newest ones first.
+      Revisions.new(revisions).reverse
+    end
+
+    def name
+      @name
     end
 
     def edit(file)
@@ -265,7 +270,7 @@ module RSCM
     end
 
     def add(relative_path)
-      add_file(@rootdir + "/" + relative_path)
+      add_file(rootdir + "/" + relative_path)
     end
 
     def add_all(files)
@@ -284,8 +289,8 @@ module RSCM
       cmd = to_identifier.nil? ? "sync" : "sync //...@#{to_identifier}"
       checked_out_files = []
       p4(cmd).collect do |output|
-        puts "output: '#{output}'"
-        if(output =~ /.* - (added as|updating|deleted as) #{@rootdir}[\/|\\](.*)/)
+        #puts "output: '#{output}'"
+        if(output =~ /.* - (added as|updating|deleted as) #{rootdir}[\/|\\](.*)/)
           path = $2.gsub(/\\/, "/")
           checked_out_files << path
           yield path if block_given?
@@ -294,8 +299,26 @@ module RSCM
       checked_out_files
     end
 
+    def diff(r)
+      path = File.expand_path(@checkout_dir + "/" + r.path)
+      from = r.previous_native_revision_identifier
+      to = r.native_revision_identifier
+      cmd = p4cmd("diff2 -du #{path}@#{from} #{path}@#{to}")
+      Better.popen(cmd) do |io|
+        return(yield(io))
+      end
+    end
+
   private
 
+    def rootdir
+      unless @rootdir
+        p4("info") =~ /Client root: (.+)/
+        @rootdir = $1
+      end
+      @rootdir
+    end
+
     def add_file(absolute_path)
       absolute_path = PathConverter.filepath_to_nativepath(absolute_path, true)
       p4("add #{absolute_path}")
@@ -310,48 +333,53 @@ module RSCM
       end
     end
 
-    def to_changeset(changelist)
+    def to_revision(changelist)
       return nil if changelist.nil? # Ugly, but it seems to be nil some times on windows.
       changes = changelist.files.collect do |filespec|
-        change = Change.new(filespec.path, changelist.developer, changelist.message, filespec.revision, changelist.time)
+        change = RevisionFile.new(filespec.path, changelist.developer, changelist.message, filespec.revision, changelist.time)
         change.status = STATUS[filespec.status]
-        change.previous_revision = filespec.revision - 1
+        change.previous_native_revision_identifier = filespec.revision - 1
         change
       end
-      changeset = ChangeSet.new(changes)
-      changeset.revision = changelist.number
-      changeset.developer = changelist.developer
-      changeset.message = changelist.message
-      changeset.time = changelist.time
-      changeset
+      revision = Revision.new(changes)
+      revision.identifier =  changelist.number
+      revision.developer = changelist.developer
+      revision.message = changelist.message
+      revision.time = changelist.time
+      revision
     end
 
-    def p4describe(chnum)
-      p4("describe -s #{chnum}")
+    def p4changes(from_identifier, to_identifier)
+      from = p4timespec(from_identifier, Time.epoch)
+      to = p4timespec(to_identifier, Time.infinity)
+      $stderr.puts "in p4changes translated #{from_identifier},#{to_identifier} to #{from},#{to}"
+      p4("changes //...@#{from},#{to}")
     end
 
-    def p4changes(from_identifier, to_identifier)
-      if from_identifier.nil? || from_identifier.is_a?(Time)
-        from_identifier = PERFORCE_EPOCH if from_identifier.nil? || from_identifier < PERFORCE_EPOCH
-        to_identifier = Time.infinity if to_identifier.nil?
-        from = from_identifier.strftime(DATE_FORMAT)
-        to = to_identifier.strftime(DATE_FORMAT)
-        p4("changes //...@#{from},#{to}")
+    def p4timespec(identifier, default)
+      identifier = default if identifier.nil?
+      if identifier.is_a?(Time)
+        identifier = Time.epoch if identifier < Time.epoch
+        (identifier+1).strftime(DATE_FORMAT)
       else
-        p4("changes //...@#{from_identifier},#{from_identifier}")
+        "#{identifier + 1}"
       end
     end
 
+    def p4describe(chnum)
+      p4("describe -s #{chnum}")
+    end
+
     def p4(cmd)
       cmd = "#{p4cmd(cmd)}"
-      puts "> executing: #{cmd}"
+      $stderr.puts "> executing: #{cmd}"
       output = `#{cmd}`
-      puts output
+      #puts output
       output
     end
 
     def p4cmd(cmd)
-       "p4 -p 1666 -c #{@name} #{cmd}"
+      "p4 -p #{@port} -c '#{@name}' -u '#{@user}' -P '#{@pwd}' #{cmd}"
     end
 
     def submitspec(comment)
@@ -377,7 +405,7 @@ module RSCM
       def initialize(log)
         debug log
         if(log =~ /^Change (\d+) by (.*) on (.*)$/)
-#          @number, @developer, @time = $1.to_i, $2, Time.utc(*ParseDate.parsedate($3)[0..5])
+          #@number, @developer, @time = $1.to_i, $2, Time.utc(*ParseDate.parsedate($3)[0..5])
           @number, @developer, @time = $1.to_i, $2, Time.utc(*ParseDate.parsedate($3))
         else
           raise "Bad log format: '#{log}'"
@@ -397,6 +425,40 @@ module RSCM
     end
   end
 
+  class P4Daemon
+    include FileUtils
+
+    def initialize(depotpath)
+      @depotpath = depotpath
+    end
+
+    def start
+      launch
+      assert_running
+    end
+
+    def assert_running
+      raise "p4d did not start properly" if timeout(10) { running? }
+    end
+
+    def launch
+      fork do
+        mkdir_p(@depotpath)
+        cd(@depotpath)
+        debug "starting p4 server"
+        exec("p4d")
+      end
+      at_exit { shutdown }
+    end
+
+    def shutdown
+      `p4 -p 1666 admin stop` if running?
+    end
+
+    def running?
+      `p4 -p 1666 info 2>&1`!~ /Connect to server failed/
+    end
+  end
 end
 
 module Kernel
@@ -412,7 +474,7 @@ module Kernel
 
   #todo: replace with logger
   def debug(msg)
-    puts msg
+    #puts msg
   end
 
 end