redcar-dev 0.12.17dev

data/plugins/scm_svn/features/step_definitions/checkout_steps.rb

@@ -0,0 +1,25 @@
+#TODO: find a way to test the http and svn protocols
+When /^I checkout "([^"]*)" in a local repository$/ do |subdirectory|
+  path = create_dir(working_copy)
+  path = path + "#{subdirectory}" if subdirectory
+  File.mkdir_p(path) unless File.exist?(path)
+  svn_module.load(path)
+  svn_module.remote_init(svn_repository_url,path)
+end
+
+When /^I checkout a local repository$/ do
+  path = create_dir(working_copy)
+  svn_module.load(path)
+  svn_module.remote_init(svn_repository_url,path)
+end
+
+Then /^I should have a working copy$/ do
+  svn_module.repository?(get_dir(working_copy)).should == true
+end
+
+Then /^if I checkout to a new working copy, it should have "([^"]*)" files$/ do |file_count|
+  path = create_dir(working_copy_2)
+  svn_module_2.load(path)
+  svn_module_2.remote_init(svn_repository_url,path)
+  repo_file_count(svn_module_2.path).should == file_count.to_i
+end

data/plugins/scm_svn/features/step_definitions/edit_and_index_steps.rb

@@ -0,0 +1,50 @@
+When /^I add "([^"]*)" to the index$/ do |files|
+  files.split(",").each do |file|
+    svn_module.index_add(File.new(get_dir(working_copy) + "/#{file}"))
+  end
+end
+
+When /^I create a wc file named "([^"]*)"$/ do |files|
+  files.split(",").each do |file|
+    FileUtils.touch(get_dir(working_copy) + "/#{file}")
+  end
+end
+
+When /^I create a wc directory named "([^"]*)"$/ do |dirs|
+  dirs.split(",").each do |dir|
+    FileUtils.mkdir_p get_dir(working_copy) + "/#{dir}"
+  end
+end
+
+Then /^there should be "([^"]*)" unindexed files and "([^"]*)" indexed files$/ do |ucount, count|
+    svn_module.unindexed_changes.length.should == ucount.to_i
+    svn_module.indexed_changes.length.should   ==  count.to_i
+end
+
+When /^I replace "([^"]*)" contents(| in the new copy) with "([^"]*)"$/ do |file,repo,text|
+  if repo == ""
+    File.open(get_dir(working_copy) + "/#{file}", 'w') do |f|
+      f.rewind
+      f.truncate(0)
+      f.puts text
+    end
+  else
+    File.open(get_dir(working_copy_2) + "/#{file}", 'w') do |f|
+      f.rewind
+      f.truncate(0)
+      f.puts text
+    end
+  end
+end
+
+Then /^the contents of wc file "([^"]*)"(| in the new copy) should be "([^"]*)"$/ do |file,repo,text|
+  if repo == " in the new copy"
+    File.read(get_dir(working_copy_2) + "/#{file}").rstrip.should == text
+  else
+    File.read(get_dir(working_copy) + "/#{file}").rstrip.should == text
+  end
+end
+
+#Then /^the contents of wc file "([^"]*)" in the new copy should be "([^"]*)"$/ do |file,text|
+#  File.read(get_dir(working_copy_2) + "/#{file}").rstrip.should == text
+#end

data/plugins/scm_svn/features/step_definitions/scm_svn_steps.rb

@@ -0,0 +1,57 @@
+
+When /^I commit my changes(| in the new copy) with message "([^"]*)"$/ do |repo,message|
+  if repo == ""
+    svn_module.commit!(message)
+  else
+    svn_module_2.commit!(message)
+  end
+end
+
+When /^I ignore "([^"]*)"$/ do |file|
+  svn_module.index_ignore(File.new(svn_module.path + "/#{file}"))
+end
+
+When /^I ignore "([^"]*)" files$/ do |extension|
+  svn_module.index_ignore_all(extension,nil)
+end
+
+When /^I wc delete "([^"]*)"$/ do |file|
+  path = svn_module.path + "/#{file}"
+  svn_module.index_delete(Redcar::Scm::Subversion::Change.new(path,:normal,[],nil))
+end
+
+When /^I revert "([^"]*)"$/ do |file|
+svn_module.index_revert(File.new(svn_module.path+"/#{file}"))
+end
+
+Then /^if I update my(| new) working copy, it should have "([^"]*)" files$/ do |repo,file_count|
+  if repo == " new"
+    svn_module_2.pull!
+    repo_file_count(svn_module_2.path).should == file_count.to_i
+  else
+    svn_module.pull!
+    repo_file_count(svn_module.path).should == file_count.to_i
+  end
+end
+
+Then /^there should be "([^"]*)" conflicted files(| in the new copy)$/ do |file_count,repo|
+  if repo == ""
+    mod = svn_module
+  else
+    mod = svn_module_2
+  end
+  changes = []
+  mod.indexed_changes.map {|i| changes << i if i.status[0] == :unmerged}
+  changes.length.should == file_count.to_i
+end
+
+When /^and I resolve "([^"]*)" conflicts(| in the new copy)$/ do |file,repo|
+  if repo == ""
+    mod = svn_module
+  else
+    mod = svn_module_2
+  end
+  changes = []
+  mod.indexed_changes.map {|i| changes << i if i.status[0] == :unmerged}
+  changes.each {|c| mod.resolve_conflict(c) if File.basename(c.path) == file}
+end

data/plugins/scm_svn/features/support/env.rb

@@ -0,0 +1,71 @@
+require File.join(Redcar.asset_dir, "svnkit")
+require 'java'
+import 'org.tmatesoft.svn.core.io.SVNRepositoryFactory'
+
+def scm_svn_fixtures
+  File.expand_path(File.dirname(__FILE__) + "/../fixtures")
+end
+
+# minus 3 for '.' and '..' and '.svn'
+def repo_file_count(path)
+  (Dir.entries(path).size - 3).to_i
+end
+
+def parse_branch_path(branch_name)
+  if branch_name == 'trunk'
+    svn_module.trunk_path
+  else
+    svn_module.branch_path + "/#{branch_name}"
+  end
+end
+
+def svn_repository
+  "#{scm_svn_fixtures}/test_repo"
+end
+
+def working_copy
+  "my_repo"
+end
+
+def working_copy_2
+  "my_repo_2"
+end
+
+def svn_repository_url
+  "file://" + File.expand_path(svn_repository)
+end
+
+def create_dir(path)
+  FileUtils.mkdir_p "#{scm_svn_fixtures}/#{path}"
+  File.expand_path("#{scm_svn_fixtures}/#{path}")
+end
+
+def get_dir(path)
+  File.expand_path("#{scm_svn_fixtures}/#{path}")
+end
+
+def svn_module
+  @svn_module ||= Redcar::Scm::Subversion::Manager.new
+end
+
+def svn_module_2
+  @svn_module_2 ||= Redcar::Scm::Subversion::Manager.new
+end
+
+def reset_fixtures
+  FileUtils.rm_rf scm_svn_fixtures
+  FileUtils.mkdir_p scm_svn_fixtures
+  FileUtils.mkdir_p File.dirname(svn_repository)
+  SVNRepositoryFactory.createLocalRepository(Java::JavaIo::File.new(svn_repository),true,false)
+  svn_module
+end
+
+Before do
+  @svn_module = nil
+  reset_fixtures
+end
+
+After do
+  FileUtils.rm_rf(scm_svn_fixtures)
+  @svn_module = nil
+end

data/plugins/scm_svn/features/switch_branches.feature

@@ -0,0 +1,53 @@
+Feature: Opening other branches as new projects
+
+  Scenario: Opening a branch from trunk
+    When I checkout a local repository
+    And I create a wc directory named "trunk,branches,branches/version1,branches/version2"
+    And I create a wc file named "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt"
+    And I add "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt" to the index
+    And I commit my changes with message "Initial commit"
+    Given I will open "trunk" branch as a new project
+    When I open a directory
+    And I note the number of windows
+    And I switch to "version1" branch
+    Then I should see 1 more window
+    And the window should have title "version1"
+
+  Scenario: Opening a branch from another branch
+    When I checkout a local repository
+    And I create a wc directory named "trunk,branches,branches/version1,branches/version2"
+    And I create a wc file named "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt"
+    And I add "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt" to the index
+    And I commit my changes with message "Initial commit"
+    Given I will open "version1" branch as a new project
+    When I open a directory
+    And I note the number of windows
+    And I switch to "version2" branch
+    Then I should see 1 more window
+    And the window should have title "version2"
+
+  Scenario: Opening trunk from a branch
+    When I checkout a local repository
+    And I create a wc directory named "trunk,branches,branches/version1,branches/version2"
+    And I create a wc file named "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt"
+    And I add "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt" to the index
+    And I commit my changes with message "Initial commit"
+    Given I will open "version1" branch as a new project
+    When I open a directory
+    And I note the number of windows
+    And I switch to "trunk" branch
+    Then I should see 1 more window
+    And the window should have title "trunk"
+
+  Scenario: Attempting to open the same branch from the branching dialog
+    When I checkout a local repository
+    And I create a wc directory named "trunk,branches,branches/version1,branches/version2"
+    And I create a wc file named "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt"
+    And I add "trunk/a.txt,branches/version1/b.txt,branches/version2/c.txt" to the index
+    And I commit my changes with message "Initial commit"
+    Given I will open "version1" branch as a new project
+    When I open a directory
+    And I note the number of windows
+    And I switch to "version1" branch
+    Then I should see 0 more windows
+    And the window should have title "version1"

data/plugins/scm_svn/features/update.feature

@@ -0,0 +1,16 @@
+Feature: Updating a working copy from a remote repository
+
+  Scenario: Updating a working copy
+    When I checkout a local repository
+    And I create a wc file named "foo.rb"
+    And I replace "foo.rb" contents with "Never gonna make you cry"
+    And I add "foo.rb" to the index
+    And I commit my changes with message "Hark! This is a commit."
+    Then if I checkout to a new working copy, it should have "1" files
+    And the contents of wc file "foo.rb" in the new copy should be "Never gonna make you cry"
+    When I replace "foo.rb" contents with "Never gonna say goodbye"
+    And I create a wc file named "bar.rb"
+    And I add "bar.rb" to the index
+    And I commit my changes with message "Yarr! This is another commit."
+    Then if I update my new working copy, it should have "2" files
+    And the contents of wc file "foo.rb" in the new copy should be "Never gonna say goodbye"

data/plugins/scm_svn/lib/scm_svn.rb

@@ -0,0 +1,445 @@
+
+require 'java'
+require 'scm_svn/change'
+require 'redcar-svnkit'
+require Redcar::SvnKit.jar_path
+
+module Redcar
+  module Scm
+    module Subversion
+      class Manager
+        include Redcar::Scm::Model
+        attr_reader :path
+        include_package 'org.tmatesoft.svn.core.wc'
+        include_package 'org.tmatesoft.svn.core'
+        import 'org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory'
+        import 'org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl'
+        import 'org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory'
+        import 'org.tmatesoft.svn.core.io.SVNRepositoryFactory'
+
+        def client_manager
+          @manager ||= begin
+            m = SVNClientManager.newInstance()
+            DAVRepositoryFactory.setup()
+            SVNRepositoryFactoryImpl.setup()
+            FSRepositoryFactory.setup()
+            m
+          end
+        end
+
+        def repository_type
+          "subversion"
+        end
+
+        def self.scm_module
+          Redcar::Scm::Subversion::Manager
+        end
+
+        def self.supported?
+          true
+        end
+
+        def load(path)
+          raise "Already loaded repository" if @path
+          @path = path
+        end
+
+        def repository?(path)
+          File.exist?(File.join(path, %w{.svn}))
+        end
+
+        def refresh
+          cache.refresh
+        end
+
+        def cache
+          @cache ||= begin
+            c = BlockCache.new
+          end
+        end
+
+        def supported_commands
+          [:pull,:commit,:remote_init,:index,:switch_branch,:merge]
+        end
+
+        def trunk_path
+          if @path.include?('trunk')
+            trunk_path = @path[0,@path.index('trunk')] + 'trunk'
+          elsif @path.include?('branches')
+            trunk_path = @path[0,@path.index('branches')] + 'trunk'
+          else
+            trunk_path = @path + "/trunk"
+          end
+          trunk_path if repository?(trunk_path)
+        end
+
+        def branch_path
+          if trunk_path # no branches without a trunk
+            branch_path = trunk_path[0,trunk_path.index('trunk')] +'branches'
+          end
+          branch_path if branch_path and repository?(branch_path)
+        end
+
+        def branches
+          if trunk_path
+            branch_list = ['trunk']
+            if branch_path
+              Dir["#{branch_path}/*/"].map do |path|
+                branch_list << File.basename(path) if repository?(path)
+              end
+            end
+          else
+            branch_list = [File.basename(@path)]
+          end
+          branch_list
+        end
+
+        def current_branch
+          branch = File.basename(@path)
+          if trunk_path
+            if @path.include?(trunk_path) and repository?(trunk_path)
+                branch = 'trunk'
+            elsif @path.include?(branch_path) and repository?(branch_path)
+              Dir["#{branch_path}/*/"].map do |path|
+                branch = File.basename(path) if @path.include?(path)
+              end
+            end
+          end
+          branch
+        end
+
+        def switch!(branch)
+          unless current_branch == branch
+            if branch == "trunk"
+              new_path = trunk_path
+            else
+              new_path = "#{branch_path}/#{branch}"
+            end
+            if new_path and File.exist?(new_path)
+              window = Redcar.app.windows.detect {|w| w.title == File.basename(new_path)}
+              if window
+                Redcar.app.set_focussed_window(window)
+              else
+                Project::DirectoryOpenCommand.new(new_path).run
+              end
+            else
+              Application::Dialog.message_box("Path not found: #{new_path}.")
+            end
+          end
+        end
+
+        def merge!(branch)
+          unless current_branch == branch
+            if branch == "trunk"
+              new_path = trunk_path
+            else
+              new_path = "#{branch_path}/#{branch}"
+            end
+            if new_path and File.exist?(new_path)
+              client_manager.getDiffClient().doMerge(
+                Java::JavaIo::File.new(path), # current branch
+                SVNRevision::HEAD,
+                Java::JavaIo::File.new(new_path), # other branch
+                SVNRevision::HEAD,
+                Java::JavaIo::File.new(path), # destination
+                SVNDepth::INFINITY,
+                true,  # useAncestry - if true then the paths ancestry will be noticed while calculating differences, otherwise not
+                false, # force - true to force the operation to run
+                false, # dryRun - if true then runs merge without any file changes
+                false  # recordOnly - if true, records only the rusult of merge - mergeinfo data
+              )
+            end
+          end
+        end
+
+        def pull!(path=nil)
+          path = @path if not path
+          if repository?(@path)
+            client_manager.getUpdateClient().doUpdate(
+              Java::JavaIo::File.new(path),
+              SVNRevision::HEAD,
+              true, # allow unversioned files to exist in directory
+              false # store depth in directory
+            )
+          else
+            Application::Dialog.message_box("#{@path} is not a working copy.")
+          end
+        end
+
+        def remote_init(path,target)
+          client_manager.getUpdateClient().doCheckout(
+            SVNURL.parseURIEncoded(path),
+            Java::JavaIo::File.new(target),
+            SVNRevision::HEAD,
+            SVNRevision::HEAD,
+            SVNDepth::INFINITY,
+            true # allow unversioned files to exist already in directory
+          )
+        end
+
+        def index_add(change)
+          client_manager.getWCClient().doAdd(
+          Java::JavaIo::File.new(change.path), #wc item file
+            false, # if true, this method does not throw exceptions on already-versioned items
+            false, # if true, create a directory also at path
+            false, # not used; make use of makeParents instead
+            SVNDepth::INFINITY, #tree depth
+            false, # if true, does not apply ignore patterns to paths being added
+            true   # if true, climb upper and schedule also all unversioned paths in the way
+          )
+          true # refresh tree
+        end
+
+        def index_ignore(change)
+          ignore_under_path(Java::JavaIo::File.new(File.dirname(change.path)).getAbsolutePath(),File.basename(change.path))
+          true # refresh tree
+        end
+
+        def index_ignore_all(extension,change)
+          ignore_under_path(@path,"*.#{extension}")
+          true
+        end
+
+        def ignore_under_path(path,pattern)
+          dir = Java::JavaIo::File.new(path)
+          prop = client_manager.getWCClient().doGetProperty(dir, SVNProperty::IGNORE,
+            SVNRevision::BASE, SVNRevision::WORKING)
+          if prop and not prop.getValue().toString().strip.empty?
+            prop = prop.getValue().toString() + "\n#{pattern}"
+          else
+            prop = pattern
+          end
+          client_manager.getWCClient().doSetProperty(dir, SVNProperty::IGNORE,
+            SVNPropertyValue.create(prop), false, false, nil)
+        end
+
+        def index_revert(change)
+          change_lists = Java::JavaUtil::ArrayList.new
+          client_manager.getWCClient().doRevert(
+            [Java::JavaIo::File.new(change.path)].to_java(Java::JavaIo::File),
+            SVNDepth::INFINITY,
+            change_lists # might be useful later
+          )
+          true # refresh tree
+        end
+
+        def index_delete(change)
+          if change.status[0] == :new
+            File.delete(change.path)
+          elsif change.status[0] == :indexed
+            index_unsave(change)
+            File.delete(File.new(change.path))
+          else
+            client_manager.getWCClient().doDelete(
+            Java::JavaIo::File.new(change.path),
+              false, # true to force operation to run
+              false, # true to delete files from filesystem
+              false  # true to do a dry run
+            )
+          end
+        end
+
+        def index_save(change)
+          if change.status[0] == :unmerged
+            resolve_conflict(change)
+          end
+        end
+
+        def index_restore(change)
+          if change.status[0] == :missing
+            client_manager.getUpdateClient().doUpdate(
+              Java::JavaIo::File.new(change.path),
+              SVNRevision::HEAD,
+              SVNDepth::INFINITY,
+              true,
+              false
+            )
+          end
+        end
+
+        def index_unsave(change)
+          if change.status[0] == :new
+            # Do nothing, there's nothing to unsave
+          elsif change.status[0] == :indexed
+            index_revert(change)
+          else
+            Application::Dialog.message_box("#{change.path} is already in the repository. Use 'delete' to remove or revert to cancel local changes.")
+          end
+        end
+
+        def commit!(message,change=nil)
+          committer = client_manager.getCommitClient()
+          if change
+            paths = [Java::JavaIo::File.new(change.path)]
+          else
+            paths = []
+            indexed_changes.each { |c| paths << Java::JavaIo::File.new(c.path) }
+          end
+          packet = committer.doCollectCommitItems(
+                    paths.to_java(Java::JavaIo::File),
+                    true,  # keep locks
+                    false, # true to force
+                    SVNDepth::INFINITY, # tree depth
+                    [].to_java(:string) # changelist names array
+                   )
+          idx = message.index(log_divider_message)
+          message = message[0,idx] if idx
+          committer.doCommit(packet, true, message)
+          true
+        end
+
+        def commit_message(change=nil)
+          msg = "\n\n#{log_divider_message}\n\n"
+          if change
+            msg << change.log_status + "\n"
+          else
+            indexed_changes.each do |c|
+              msg << c.log_status + "\n"
+            end
+          end
+          msg
+        end
+
+        def log_divider_message
+          "--This line, and those below, will be ignored--"
+        end
+
+        def uncommited_changes
+          indexed_changes + unindexed_changes
+        end
+
+        def unindexed_changes
+          populate_changes(@path,false)
+        end
+
+        def indexed_changes
+          populate_changes(@path,true)
+        end
+
+        def populate_changes(path,indexed)
+          nodes = []
+          find_dirs(path,indexed,nodes)
+          nodes.sort_by{|node| node.path}.sort_by do |node|
+            if File.directory?(node.path)
+              0
+            else
+              1
+            end
+          end
+        end
+
+        def find_dirs(path,indexed,nodes=[])
+          Dir["#{path.to_s}/*/"].map do |a|
+            #FIXME: find dirs beneath iff 'a' is not ignored
+            status = client_manager.getStatusClient().doStatus(
+              Java::JavaIo::File.new(a),false).getContentsStatus()
+            find_dirs(a,indexed,nodes) if versioned_statuses.include?(status)
+            status = check_file_status(a,indexed)
+            if status
+              diff_client = client_manager.getDiffClient()
+              nodes << Scm::Subversion::Change.new(a,status,[],diff_client)
+            end
+          end
+          check_files(path,indexed,nodes)
+        end
+
+        def check_files(path,indexed,nodes)
+          files = File.join(path.to_s, "*")
+          Dir.glob(files).each do |file_path|
+            if File.file?(file_path)
+              status = check_file_status(file_path,indexed)
+              if status
+                diff_client = client_manager.getDiffClient()
+                nodes << Scm::Subversion::Change.new(file_path,status,[],diff_client)
+              end
+            end
+          end
+        end
+
+        def check_file_status(path,indexed)
+          status_client = client_manager.getStatusClient()
+          status = status_client.doStatus(Java::JavaIo::File.new(path),false).getContentsStatus()
+          if indexed
+            s = case status
+            when SVNStatusType::STATUS_MODIFIED   then :changed
+            when SVNStatusType::STATUS_MISSING    then :missing
+            when SVNStatusType::STATUS_DELETED    then :deleted
+            when SVNStatusType::STATUS_ADDED      then :indexed
+            when SVNStatusType::STATUS_CONFLICTED then :unmerged
+            end
+            s
+          else
+            s = case status
+            when SVNStatusType::STATUS_UNVERSIONED then :new
+            end
+            s
+          end
+        end
+
+        def versioned_statuses
+          [
+          SVNStatusType::STATUS_MODIFIED,
+          SVNStatusType::STATUS_MISSING,
+          SVNStatusType::STATUS_DELETED,
+          SVNStatusType::STATUS_ADDED,
+          SVNStatusType::STATUS_CONFLICTED,
+          SVNStatusType::STATUS_NORMAL
+          ]
+        end
+
+        def resolve_conflict(change)
+          client_manager.getWCClient().doResolve(
+            Java::JavaIo::File.new(change.path),
+            SVNDepth::IMMEDIATES, # change and files beneath
+            true, # resolve contents conflict
+            true, # resolve property conflict
+            true, # resolve tree conflict -- man, I hate those
+            SVNConflictChoice.MERGED # choose file as edited and resolved
+          )
+        end
+
+        def file_diff(path)
+          differ = client_manager.getDiffClient()
+          stream = Java::JavaIo::ByteArrayOutputStream.new
+          file   = Java::JavaIo::File.new(path)
+          change_lists = Java::JavaUtil::ArrayList.new
+          differ.doDiff(file, SVNRevision::BASE,
+                        file, SVNRevision::WORKING,
+                        SVNDepth::IMMEDIATES,
+                        false,
+                        stream,
+                        change_lists)
+          stream.toString()
+        end
+
+        def translations
+          t = super
+          t[:index_unsave] = "Remove from commit"
+          t[:indexed_changes] = "Uncommitted changes"
+          t[:unindexed_changes] = "External files"
+          t[:remote_init] = "Checkout Subversion Repository"
+          t[:push] = "Commit changes",
+          t[:pull] = "Update working copy",
+          t[:switch_branches] = "Open branch"
+          t
+        end
+
+        def self.debug
+          Redcar::Scm::Manager.debug
+        end
+
+        def debug
+          Redcar::Scm::Subversion::Manager.debug
+        end
+
+        def inspect
+          if @path
+            %Q{#<Scm::Subversion::Manager "#{@path}">}
+          else
+            %Q{#<Scm::Subversion::Manager>}
+          end
+        end
+      end
+    end
+  end
+end