rscm 0.1.0.1338 → 0.2.0

data/lib/rscm/{darcs → scm}/darcs.rb

@@ -1,12 +1,15 @@
-require 'rscm/abstract_scm'
 require 'tempfile'
-require 'rscm/path_converter'
 require 'fileutils'
+require 'rscm'
 
 module RSCM
   class Darcs < AbstractSCM
+    register self
 
-    def initialize(dir=nil)
+    ann :description => "Directory"
+    attr_accessor :dir
+
+    def initialize(dir=".")
       @dir = File.expand_path(dir)
     end
 

data/lib/rscm/scm/monotone.rb

@@ -0,0 +1,162 @@
+require 'fileutils'
+require 'rscm'
+
+module RSCM
+  class Monotone < AbstractSCM
+    register self
+
+    ann :description => "Database file"
+    attr_accessor :db_file
+
+    ann :description => "Branch"
+    attr_accessor :branch
+
+    ann :description => "Key"
+    attr_accessor :key
+
+    ann :description => "Passphrase"
+    attr_accessor :passphrase
+
+    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)
+      @branch = branch
+      @key = key
+      @passphrase = passphrase
+      @keys_file = keys_file
+    end
+
+    def name
+      "Monotone"
+    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
+    end
+
+    def transactional?
+      true
+    end
+
+    def import(dir, message)
+      dir = File.expand_path(dir)
+
+      # post 0.17, this can be "cd dir && cmd add ."
+
+      files = Dir["#{dir}/*"]
+      relative_paths_to_add = to_relative(dir, files)
+
+      with_working_dir(dir) do
+        monotone("add #{relative_paths_to_add.join(' ')}")
+        monotone("commit '#{message}'", @branch, @key) do |io|
+          io.puts(@passphrase)
+          io.close_write
+          io.read
+        end
+      end
+    end
+
+    def checked_out?(checkout_dir)
+      File.exists?("#{checkout_dir}/MT")
+    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
+      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
+    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
+      end
+      head_revision
+    end
+
+    def changesets(checkout_dir, 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
+        monotone("log", @branch, @key) do |stdout|
+          MonotoneLogParser.new.parse_changesets(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|
+          io.puts(@passphrase)
+          io.close_write
+          io.read
+        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
+      end
+    end
+
+    # Administrative files that should be ignored when counting files.
+    def ignore_paths
+      return [/MT/, /\.mt-attrs/]
+    end
+
+  private
+  
+    def monotone(monotone_cmd, branch=nil, key=nil)
+      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|
+        if(block_given?)
+          return(yield(io))
+        else
+          # just read stdout so we can exit
+          io.read
+        end
+      end
+    end
+  
+  end
+end

data/lib/rscm/scm/monotone_log_parser.rb

@@ -0,0 +1,95 @@
+require 'rscm'
+require 'time'
+require 'stringio'
+
+module RSCM
+
+  class MonotoneLogParser
+  
+    def parse_changesets(io, from_identifier=Time.epoch, to_identifier=Time.infinity)
+      # skip first separator
+      io.readline
+      
+      changesets = ChangeSets.new
+      changeset_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 = ""
+        else
+          changeset_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]
+        end
+      end
+      changesets
+    end
+
+    def parse_changeset(changeset_io, path_revisions)
+      changeset = ChangeSet.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(
+            $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:$/ && changeset.message.nil?)
+          state = :message
+        elsif(state == :message && changeset.message.nil?)
+          changeset.message = ""
+        elsif(state == :message && changeset.message)
+          changeset.message << line
+        elsif(line =~ /^Added files:$/)
+          state = :added
+        elsif(state == :added)
+          add_changes(changeset, line, Change::ADDED, path_revisions)
+        elsif(line =~ /^Modified files:$/)
+          state = :modified
+        elsif(state == :modified)
+          add_changes(changeset, line, Change::MODIFIED, path_revisions)
+        end
+      end
+      changeset.message.chomp!
+      changeset
+    end
+    
+  private
+
+    def add_changes(changeset, line, state, path_revisions)
+      paths = line.split(" ")
+      paths.each do |path|
+        changeset << Change.new(path, state, changeset.developer, nil, changeset.revision, changeset.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
+      end
+      
+    end
+  end
+
+end

data/lib/rscm/scm/mooky.rb

@@ -0,0 +1,21 @@
+require 'rscm/abstract_scm'
+
+module RSCM
+  class Mooky < AbstractSCM
+    register self
+
+    ann :description => "The Foo", :tip => "Foo is nonsense"
+    attr_accessor :foo
+
+    ann :description => "Le Bar", :tip => "Bar toi!"
+    attr_accessor :bar
+  
+    def initialize(foo="", bar="chocolate bar")
+    end
+  
+    def name
+      "Mooky"
+    end
+
+  end
+end

data/lib/rscm/{perforce → scm}/perforce.rb

@@ -15,11 +15,14 @@ module RSCM
   # You need the p4/p4d executable on the PATH in order for it to work.
   #
   class Perforce < AbstractSCM
+    register self
+
     include FileUtils
 
+    ann :description => "Depot path", :tip => "The path to the Perforce depot"
     attr_accessor :depotpath
 
-    def initialize(repository_root_dir = nil)
+    def initialize(repository_root_dir = "")
       @clients = {}
       @depotpath = repository_root_dir
     end
@@ -55,8 +58,8 @@ module RSCM
       client(checkout_dir).submit(message, &proc)
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier = nil, files = nil)
-      client(checkout_dir).changesets(from_identifier, to_identifier, files)
+    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
+      client(checkout_dir).changesets(from_identifier, to_identifier)
     end
 
     def uptodate?(checkout_dir, from_identifier)
@@ -251,7 +254,7 @@ module RSCM
       p4("sync -n").empty?
     end
 
-    def changesets(from_identifier, to_identifier, files)
+    def changesets(from_identifier, to_identifier)
       changesets = changelists(from_identifier, to_identifier).collect {|changelist| to_changeset(changelist)}
       ChangeSets.new(changesets)
     end

data/lib/rscm/{starteam/starteam.rb → scm/star_team.rb}

@@ -18,10 +18,30 @@ module RSCM
   # * Apache Ant (http://ant.apache.org/)
   #
   class StarTeam < AbstractSCM
+    register self
 
-    attr_accessor :user_name, :password, :server_name, :server_port, :project_name, :view_name, :folder_name
+    ann :description => "User name"
+    attr_accessor :user_name
 
-    def initialize(user_name=nil, password=nil, server_name=nil, server_port=nil, project_name=nil, view_name=nil, folder_name=nil)
+    ann :description => "Password"
+    attr_accessor :password
+
+    ann :description => "Server name"
+    attr_accessor :server_name
+
+    ann :description => "Server port"
+    attr_accessor :server_port
+
+    ann :description => "Project name"
+    attr_accessor :project_name
+
+    ann :description => "View name"
+    attr_accessor :view_name
+
+    ann :description => "Folder 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
 
@@ -29,7 +49,7 @@ module RSCM
       "StarTeam"
     end
     
-    def changesets(checkout_dir, from_identifier=Time.epoch, to_identifier=Time.infinity, files=nil, &proc)
+    def changesets(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

data/lib/rscm/{svn/svn.rb → scm/subversion.rb}

@@ -1,7 +1,7 @@
 require 'rscm/abstract_scm'
 require 'rscm/path_converter'
 require 'rscm/line_editor'
-require 'rscm/svn/svn_log_parser'
+require 'rscm/scm/subversion_log_parser'
 
 module RSCM
 
@@ -10,14 +10,21 @@ module RSCM
   # 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 SVN < AbstractSCM
+  class Subversion < AbstractSCM
+    register self
+
     include FileUtils
     include PathConverter
     
+    ann :description => "Repository URL"
+    ann :tip => "If you specify a local URL (starting with file://) DamageControl can create the repository for you after you save (unless the repository already exists).<br>Using a file:// URL will also give you the option to have DamageControl install a trigger in Subversion, so that you don't have to use polling to detect changes.<br>On Windows, file URLs must look like file:///C:/jupiter/mars"
     attr_accessor :url
+
+    ann :description => "Path"
+    ann :tip => "This is the relative path from the start of the repository <br>to the end of the URL. For example, if your URL is <br>svn://your.server/path/to/repository/path/within/repository <br>then this value should be path/within/repository."
     attr_accessor :path
 
-    def initialize(url=nil, path="")
+    def initialize(url="", path="trunk")
       @url, @path = url, path
     end
 
@@ -98,7 +105,7 @@ module RSCM
       cmd = "svn log #{repourl} -r HEAD"
       with_working_dir(checkout_dir) do
         safer_popen(cmd) do |stdout|
-          parser = SVNLogParser.new(stdout, path, checkout_dir)
+          parser = SubversionLogParser.new(stdout, path, checkout_dir)
           changesets = parser.parse_changesets
           changesets[0].revision.to_i
         end
@@ -117,7 +124,7 @@ module RSCM
 
     def diff(checkout_dir, change, &block)
       with_working_dir(checkout_dir) do
-        cmd = "svn diff -r #{change.previous_revision}:#{change.revision} #{url}/#{change.path}"
+        cmd = "svn diff -r #{change.previous_revision}:#{change.revision} \"#{url}/#{change.path}\""
         safer_popen(cmd) do |io|
           return(yield(io))
         end
@@ -179,18 +186,18 @@ module RSCM
       svn(dir, import_cmd)
     end
 
-    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity, files=nil)
+    def changesets(checkout_dir, from_identifier, to_identifier=Time.infinity)
       # Return empty changeset if the requested revision doesn't exist yet.
       return ChangeSets.new if(from_identifier.is_a?(Integer) && head_revision(checkout_dir) < from_identifier)
 
       checkout_dir = PathConverter.filepath_to_nativepath(checkout_dir, false)
       changesets = nil
-      command = "svn #{changes_command(from_identifier, to_identifier, files)}"
+      command = "svn #{changes_command(from_identifier, to_identifier)}"
       yield command if block_given?
 
       with_working_dir(checkout_dir) do
         safer_popen(command) do |stdout|
-          parser = SVNLogParser.new(stdout, path, checkout_dir)
+          parser = SubversionLogParser.new(stdout, path, checkout_dir)
           changesets = parser.parse_changesets
         end
       end
@@ -274,7 +281,7 @@ module RSCM
       "update #{revision_option(nil,to_identifier)}"
     end
     
-    def changes_command(from_identifier, to_identifier, files)
+    def changes_command(from_identifier, to_identifier)
       # http://svnbook.red-bean.com/svnbook-1.1/svn-book.html#svn-ch-3-sect-3.3
       # file_list = files.join('\n')
 # WEIRD cygwin bug garbles this!?!?!?!
@@ -312,7 +319,7 @@ module RSCM
     
     def svndate(time)
       return nil unless time
-      time.utc.strftime("\"{%Y-%m-%d %H:%M:%S\"}")
+      time.utc.strftime("{\"%Y-%m-%d %H:%M:%S\"}")
     end
 
     def commit_command(message)