rscm 0.3.16 → 0.4.0

data/lib/rscm/scm/cvs_log_parser.rb

@@ -52,13 +52,8 @@ module RSCM
         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$/
-
-        revision = revisions.add(file)
-        # CVS doesn't have revision for revisions, use
-        # Fisheye-style revision
-#        revision.native_revision_identifier =  "MAIN:#{file.developer}:#{file.time.utc.strftime('%Y%m%d%H%M%S')}" if revision
+        revisions.add(file)
       end
       nil
     end
@@ -83,10 +78,9 @@ module RSCM
       raise "can't parse: #{file_entry}" if file_entry =~ REVISION_SEPARATOR
          
       file_entry_lines = file_entry.split(/\r?\n/)
-      file = RevisionFile.new
 
+      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: (.*?)(;|$)/)

data/lib/rscm/scm/monotone.rb

@@ -203,7 +203,7 @@ module RSCM
 
     # Administrative files that should be ignored when counting files.
     def ignore_paths
-      return [/MT/, /\.mt-attrs/]
+      [/MT/, /\.mt-attrs/]
     end
 
   private

data/lib/rscm/scm/subversion.rb

@@ -25,101 +25,56 @@ module RSCM
       @username = ""
       @password = ""
     end
+
+    def to_identifier(raw_identifier)
+      raw_identifier.to_i
+    end
     
-    def add(relative_filename)
-      svn(@checkout_dir, "add #{relative_filename}")
+    def add(relative_filename, options={})
+      svn("add #{relative_filename}", options)
     end
 
-    def move(relative_src, relative_dest)
-      svn(@checkout_dir, "mv #{relative_src} #{relative_dest}")
+    def move(relative_src, relative_dest, options={})
+      svn("mv #{relative_src} #{relative_dest}", options)
     end
 
     def transactional?
       true
     end
 
-    def checkout(to_identifier=nil)
-      checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
-      mkdir_p(@checkout_dir)
-      checked_out_files = []
-      path_regex = /^[A|D|U]\s+(.*)/
-      if(checked_out?)
-        svn(@checkout_dir, update_command(to_identifier)) do |line|
-          if(line =~ path_regex)
-            absolute_path = "#{checkout_dir}/#{$1}"
-            relative_path = $1.chomp
-            relative_path = relative_path.gsub(/\\/, "/") if WINDOWS
-            checked_out_files << relative_path
-            yield relative_path if block_given?
-          end
-        end
-      else
-        svn(@checkout_dir, checkout_command(to_identifier)) do |line|
-          if(line =~ path_regex)
-            native_absolute_path = $1
-            absolute_path = PathConverter.nativepath_to_filepath(native_absolute_path)
-            if(File.exist?(absolute_path) && !File.directory?(absolute_path))
-              native_checkout_dir = PathConverter.filepath_to_nativepath(@checkout_dir, false)
-              relative_path = native_absolute_path[native_checkout_dir.length+1..-1].chomp
-              relative_path = relative_path.gsub(/\\/, "/")
-              checked_out_files << relative_path
-              yield relative_path if block_given?
-            end
-          end
-        end
-      end
-      checked_out_files
-    end
-
-    def uptodate?(identifier)
+    def uptodate?(identifier, options={})
       if(!checked_out?)
         false
       else
-        rev = identifier ? identifier : head_revision_identifier
-        local_revision_identifier == rev
+        rev = identifier.nil? ? head_revision_identifier(options) : identifier 
+        local_revision_identifier(options) == rev
       end
     end
 
-    def commit(message)
-      svn(@checkout_dir, commit_command(message))
+    def commit(message, options={})
+      svn(commit_command(message), options)
       # We have to do an update to get the local revision right
-      svn(@checkout_dir, "update")
+      svn("update", options)
     end
 
     def label
       local_revision_identifier.to_s
     end
 
-    def diff(file, &block)
+    def diff(file, options={}, &block)
       cmd = "svn diff --revision #{file.previous_native_revision_identifier}:#{file.native_revision_identifier} \"#{url}/#{file.path}\""
-      Better.popen(cmd) do |io|
+      execute(cmd, options) do |io|
         return(yield(io))
       end
     end
     
-    def open(revision_file, &block)
+    def open(revision_file, options, &block)
       cmd = "svn cat #{url}/#{revision_file.path}@#{revision_file.native_revision_identifier}"
-      Better.popen(cmd) do |io|
+      execute(cmd, options) do |io|
         return(yield(io))
       end
     end
 
-    def ls(relative_path)
-      prefix = relative_path == "" ? relative_path : "#{relative_path}/"
-      cmd = "svn ls #{url}/#{relative_path}"
-      Better.popen(cmd) do |io|
-        io.collect do |line|
-          name = line.strip
-          dir = false
-          if(name =~ /(.*)\/$/)
-            name = $1
-            dir = true
-          end
-          HistoricFile.new("#{prefix}#{name}", dir, self)
-        end
-      end
-    end
-
     def can_create_central?
       local?
     end
@@ -141,7 +96,7 @@ module RSCM
         # on stdout (and an error msg on std err).
         exists = false
         cmd = "svn log #{url} -r HEAD"
-        Better.popen(cmd) do |stdout|
+        execute(cmd) do |stdout|
           stdout.each_line do |line|
             exists = true
           end
@@ -161,53 +116,58 @@ module RSCM
       "hooks/post-commit"
     end
     
-    def create_central
+    def create_central(options={})
+      options = options.dup.merge({:dir => svnrootdir})
       native_path = PathConverter.filepath_to_nativepath(svnrootdir, true)
       mkdir_p(PathConverter.nativepath_to_filepath(native_path))
-      svnadmin(svnrootdir, "create #{native_path}")
+      svnadmin("create #{native_path}", options)
       if(@path && @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\"")
+          svn("mkdir #{u} -m \"Adding directories\"", options)
         end
       end
     end
 
-    def install_trigger(trigger_command, trigger_files_checkout_dir)
+    def install_trigger(trigger_command, trigger_files_checkout_dir, options={})
       if (WINDOWS)
-        install_win_trigger(trigger_command, trigger_files_checkout_dir)
+        install_win_trigger(trigger_command, trigger_files_checkout_dir, options)
       else
-        install_unix_trigger(trigger_command, trigger_files_checkout_dir)
+        install_unix_trigger(trigger_command, trigger_files_checkout_dir, options)
       end
     end
     
-    def uninstall_trigger(trigger_command, trigger_files_checkout_dir)
+    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)
+    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, message)
-      import_cmd = "import #{url} -m \"#{message}\""
-      svn(dir, import_cmd)
-    end
-
-    def revisions(from_identifier, to_identifier=Time.infinity, relative_path="")
-      # Return empty revision if the requested revision doesn't exist yet.
-      return Revisions.new if(from_identifier.is_a?(Integer) && head_revision_identifier <= from_identifier)
-
+    def import_central(options)
+      import_cmd = "import #{url} -m \"#{options[:message]}\""
+      svn(import_cmd, options)
+    end
+
+    def revisions(from_identifier, options={})
+      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(from_identifier, to_identifier, relative_path)}"
-
-      Better.popen(command) do |stdout|
+      command = "svn #{changes_command(options[:from_identifier], options[:to_identifier], options[:relative_path])}"
+      execute(command, options) do |stdout|
         parser = SubversionLogParser.new(stdout, @url)
         revisions = parser.parse_revisions
       end
@@ -226,31 +186,47 @@ module RSCM
       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
+    def local_revision_identifier(options)
       local_revision_identifier = nil
-      svn(@checkout_dir, "info") do |line|
+      svn("info", options) do |line|
         if(line =~ /Revision: ([0-9]*)/)
           return $1.to_i
         end
       end
     end
 
-    def head_revision_identifier
+    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}"
-      Better.popen(cmd) do |stdout|
+      execute(cmd, options) do |stdout|
         parser = SubversionLogParser.new(stdout, @url)
         revisions = parser.parse_revisions
-        revisions[0].identifier.to_i
+        revisions[0].identifier
       end
     end
 
-    def install_unix_trigger(trigger_command, damagecontrol_install_dir)
+    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
@@ -267,7 +243,7 @@ module RSCM
       end
     end
     
-    def install_win_trigger(trigger_command, damagecontrol_install_dir)
+    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
@@ -291,22 +267,19 @@ module RSCM
       result
     end
 
-    def svnadmin(dir, cmd, &proc)
-      svncommand("svnadmin", dir, cmd, &proc)
+    def svnadmin(cmd, options={}, &proc)
+      svncommand("svnadmin", cmd, options, &proc)
     end
 
-    def svn(dir, cmd, &proc)
-      svncommand("svn", dir, cmd, &proc)
+    def svn(cmd, options={}, &proc)
+      svncommand("svn", cmd, options, &proc)
     end
 
-    def svncommand(executable, dir, cmd, &proc)
+    def svncommand(executable, cmd, options, &proc)
       command_line = "#{executable} #{cmd}"
-      dir = File.expand_path(dir)
-      with_working_dir(dir) do
-        Better.popen(command_line) do |stdout|
-          stdout.each_line do |line|
-            yield line if block_given?
-          end
+      execute(command_line, options) do |stdout|
+        stdout.each_line do |line|
+          yield line if block_given?
         end
       end
     end

data/lib/rscm/time_ext.rb

@@ -7,5 +7,6 @@ class Time
     def infinity
       Time.utc(2036)
     end
+    
   end
-end
+end

data/lib/rscm/version.rb

@@ -0,0 +1,13 @@
+module RSCM
+  module VERSION
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+
+    NAME = "RSCM"
+    FULLNAME = "Ruby Source Control Management"
+    URL = "http://rscm.rubyforge.org/"  
+  end
+end

data/test/rscm/generic_scm_tests.rb

@@ -4,8 +4,10 @@ require 'rscm/path_converter'
 require 'rscm/difftool_test'
 
 module RSCM
+  DEFAULT_OPTIONS = {:stdout => 'target/stdout.log', :stderr => 'target/stderr.log'}.freeze
 
   module GenericSCMTests
+    
     include FileUtils
 
     def teardown
@@ -47,15 +49,17 @@ module RSCM
       other_checkout_dir = "#{work_dir}/OtherWorkingCopy"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
 
       other_scm = create_scm(repository_dir, "damagecontrolled")
+      other_scm.default_options = DEFAULT_OPTIONS
       other_scm.checkout_dir = other_checkout_dir
 
       raise "This scm (#{scm.name}) can't create 'central' repositories." unless scm.can_create_central?
 
       # 1
-      scm.create_central
+      scm.create_central 
       @scm = scm
 
       # 2
@@ -66,25 +70,18 @@ module RSCM
       assert(!scm.uptodate?(nil))
       
       # 4
-      yielded_files = []
-      files = scm.checkout do |file_name|
-        yielded_files << file_name
-      end
-      
+      files = scm.checkout nil
+
       # 5
-      assert_equal(4, files.length)
-      assert_equal(files, yielded_files)
+      assert_equal(4, files.length, files.join("\n"))
       files.sort!
-      yielded_files.sort!
-      assert_equal(files, yielded_files)
-
       assert_equal("build.xml", files[0])
       assert_equal("project.xml", files[1])
       assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", files[2])
       assert_equal("src/test/com/thoughtworks/damagecontrolled/ThingyTestCase.java", files[3])
 
       # 6
-      initial_revisions = scm.revisions(nil, nil)
+      initial_revisions = scm.revisions(nil)
       assert_equal("imported\nsources", initial_revisions[0].message)
       # Subversion seems to add a revision with message "Added directories"
       #assert_equal(1, initial_revisions.length)
@@ -97,21 +94,20 @@ module RSCM
       change_file(scm, "#{checkout_dir}/build.xml")
       change_file(scm, "#{checkout_dir}/src/java/com/thoughtworks/damagecontrolled/Thingy.java")
 
-      # 9
-      other_scm.checkout
-      # 10
-      assert(other_scm.uptodate?(nil))
-      # 11
-      assert(scm.uptodate?(nil))
-      # 12
+      assert(!other_scm.uptodate?(initial_revisions.latest.identifier))
+      other_scm.checkout nil
+      assert(other_scm.uptodate?(initial_revisions.latest.identifier))
+
+      sleep(1)
       scm.commit("changed\nsomething") 
 
       # 13
       revisions = scm.revisions(initial_revisions.latest.identifier)
+      assert_equal(1, revisions.length, "Actual revisions:\n" + revisions.collect{|cs| cs.to_s}.join("\n"))
+
       assert(revisions[0].identifier)
-      assert_equal(1, revisions.length, revisions.collect{|cs| cs.to_s})
       revision = revisions[0]
-      assert_equal(2, revision.length)
+      assert_equal(2, revision.length, "Actual files:\n" + revision.collect{|file| file.path}.join("\n"))
 
       assert_equal("changed\nsomething", revision.message)
 
@@ -134,7 +130,7 @@ module RSCM
       assert(scm.uptodate?(revisions.latest.identifier))
 
       # 15
-      files = other_scm.checkout.sort
+      files = other_scm.checkout(nil).sort
       assert_equal(2, files.length)
       assert_equal("build.xml", files[0])
       assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", files[1])
@@ -151,19 +147,6 @@ module RSCM
       assert_equal(1, revisions.length)
       assert_equal(1, revisions[0].length)
       assert_equal("src/java/com/thoughtworks/damagecontrolled/Hello.txt", revisions[0][0].path)
-      
-      # 19
-      root_children = scm.rootdir.children
-      assert_equal "build.xml", root_children[0].relative_path
-      assert !root_children[0].directory?
-      assert_equal "project.xml", root_children[1].relative_path
-      assert !root_children[1].directory?
-      assert_equal "src", root_children[2].relative_path
-      assert root_children[2].directory?
-
-      src_children = root_children[2].children
-      assert_equal "src/java", src_children[0].relative_path
-      assert src_children[0].directory?
     end
 
     def test_create_destroy
@@ -171,11 +154,12 @@ module RSCM
       checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "killme")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
 
       (1..3).each do
         assert(!scm.central_exists?)
-        scm.create_central
+        scm.create_central 
         assert(scm.central_exists?)
         scm.destroy_central
       end
@@ -189,6 +173,7 @@ module RSCM
       repository_dir = "#{work_dir}/repository"
       trigger_proof = "#{work_dir}/trigger_proof"
       scm = create_scm(repository_dir, "damagecontrolled")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
       scm.create_central 
       @scm = scm
@@ -206,7 +191,7 @@ module RSCM
 
       # Verify that the trigger works
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
-      scm.checkout
+      scm.checkout nil
       scm.install_trigger(trigger_command, trigger_files_checkout_dir)
       assert(!File.exist?(trigger_proof))
 
@@ -219,12 +204,13 @@ module RSCM
       checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
-      scm.create_central
+      scm.create_central 
       @scm = scm
 
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
-      scm.checkout
+      scm.checkout nil
       add_or_edit_and_commit_file(scm, checkout_dir, "before.txt", "Before label")
       before_cs = scm.revisions(Time.epoch)
 
@@ -244,12 +230,13 @@ module RSCM
       checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
       scm.create_central 
       @scm = scm
 
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
-      scm.checkout
+      scm.checkout nil
       
       from = "src/java/com/thoughtworks/damagecontrolled/Thingy.java"
       to = "src/java/com/thoughtworks/damagecontrolled/Mooky.java"
@@ -258,7 +245,7 @@ module RSCM
       assert(File.exist?(scm.checkout_dir + "/" + to))
       rm_rf(scm.checkout_dir + "/" + to)
       assert(!File.exist?(scm.checkout_dir + "/" + to))
-      scm.checkout
+      scm.checkout nil
       assert(File.exist?(scm.checkout_dir + "/" + to))
     end
 
@@ -281,8 +268,9 @@ EOF
       repository_dir = "#{work_dir}/repository"
       import_dir = "#{work_dir}/import/diffing"
       scm = create_scm(repository_dir, "diffing")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
-      scm.create_central
+      scm.create_central 
       @scm = scm
       
       mkdir_p(import_dir)
@@ -290,8 +278,8 @@ EOF
         io.puts("just some")
         io.puts("initial content")
       end      
-      scm.import_central(import_dir, "Initial revision")
-      scm.checkout
+      scm.import_central :dir=>import_dir, :message=>"Importing"
+      scm.checkout nil
       initial_revision = scm.revisions(nil).latest
       sleep(1)
 
@@ -328,7 +316,7 @@ EOF
       
       # TODO: make separate test. Make helper method for the cumbersome setup!
       historic_afile = scm.file("afile.txt", false)
-      revision_files = historic_afile.revision_files
+      revision_files = historic_afile.revision_files 
       assert_equal(Array, revision_files.class)
       assert(revision_files.length >= 2)
       assert(revision_files.length <= 3)
@@ -345,7 +333,7 @@ EOF
       cp_r(path, dirname)
       todelete = Dir.glob("#{import_copy_dir}/**/.svn")
       rm_rf(todelete)
-      scm.import_central(import_copy_dir, "imported\nsources")
+      scm.import_central :dir => import_copy_dir, :message => "imported\nsources"
     end
     
     def change_file(scm, file)
@@ -379,13 +367,14 @@ EOF
       checkout_dir = "#{work_dir}/LabelTest"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
+      scm.default_options = DEFAULT_OPTIONS
       scm.checkout_dir = checkout_dir
-      scm.create_central
+      scm.create_central 
       @scm = scm
 
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
 
-      scm.checkout
+      scm.checkout nil
 
       # TODO: introduce a Revision class which implements comparator methods
       return
@@ -395,7 +384,7 @@ EOF
       )
       change_file(scm, "#{checkout_dir}/build.xml")
       scm.commit("changed something")
-      scm.checkout 
+      scm.checkout nil
       assert_equal(
         "2",
         scm.label