--- a/Support/app/controllers/branch_controller.rb
+++ b/Support/app/controllers/branch_controller.rb
@@ -77,7 +77,7 @@ class BranchController < ApplicationController
     puts "<h2>Merging #{@merge_from_branch} into #{@c_branch}</h2>"
     flush
     
-    with_submodule_stashing do
+    with_submodule_cacheing do
       @result = git.merge(@merge_from_branch)
       render "merge"
       true
@@ -147,7 +147,7 @@ class BranchController < ApplicationController
     end
     
     def switch_local(target_branch)
-      with_submodule_stashing do
+      with_submodule_cacheing do
         output = git.branch.switch(target_branch)
         case output
         when /fatal: you need to resolve your current index first/

--- a/Support/app/controllers/remote_controller.rb
+++ b/Support/app/controllers/remote_controller.rb
@@ -48,7 +48,7 @@ class RemoteController < ApplicationController
       
       puts "<p>Pulling from remote source '#{source}'\n</p>"
       
-      with_submodule_stashing do
+      with_submodule_cacheing do
         output = run_pull(source, remote_branch_name)
         puts "<pre>#{output[:text]}</pre>"
       

--- a/Support/app/helpers/submodule_helper.rb
+++ b/Support/app/helpers/submodule_helper.rb
@@ -1,7 +1,7 @@
 module SubmoduleHelper
   module Update
-    def with_submodule_stashing(&block)
-      git.submodule.all.each { |m| m.stash }
+    def with_submodule_cacheing(&block)
+      git.submodule.all.each { |m| m.cache }
       begin
         yield
       ensure

--- a/Support/lib/commands/submodule.rb
+++ b/Support/lib/commands/submodule.rb
@@ -50,27 +50,27 @@ class SCM::Git::Submodule < SCM::Git::CommandProxyBase
       path
     end
     
-    def abs_stash_path
-      @abs_stash_path ||= File.join(@base.git_base, ".git/submodule_stash", MD5.hexdigest(path + "\n" + url))
+    def abs_cache_path
+      @abs_cache_path ||= File.join(@base.git_base, ".git/submodule_cache", MD5.hexdigest(path + "\n" + url))
     end
     
     def abs_path
       @abs_path ||= File.join(@base.git_base, @path)
     end
     
-    def stash
+    def cache
       if File.exist?(abs_path)
-        FileUtils.rm_rf(abs_stash_path)
-        FileUtils.mkdir_p(File.dirname(abs_stash_path))
-        FileUtils.mv(abs_path, abs_stash_path, :force => true)
+        FileUtils.rm_rf(abs_cache_path)
+        FileUtils.mkdir_p(File.dirname(abs_cache_path))
+        FileUtils.mv(abs_path, abs_cache_path, :force => true)
         true
       end
     end
     
     def restore
-      if ! File.exist?(abs_path) && File.exist?(abs_stash_path)
+      if ! File.exist?(abs_path) && File.exist?(abs_cache_path)
         FileUtils.mkdir_p(File.dirname(abs_path))
-        FileUtils.mv(abs_stash_path, abs_path, :force => true)
+        FileUtils.mv(abs_cache_path, abs_path, :force => true)
       end
     end
   end

--- a/Support/spec/controllers/branch_controller_spec.rb
+++ b/Support/spec/controllers/branch_controller_spec.rb
@@ -88,11 +88,11 @@ EOF
       end
       
       describe "when you have submodules" do
-        it "should stash, restore, then call submodules.init_and_update" do
+        it "should cache, restore, then call submodules.init_and_update" do
           @set_branch_to_choose.call("task")
           
           git = Git.singleton_new
-          @submodule = stub("submodule", :stash => true, :restore => true)
+          @submodule = stub("submodule", :cache => true, :restore => true)
           git.submodule.should_receive(:all).any_number_of_times.and_return([@submodule])
           git.submodule.should_receive(:init_and_update)
           output = capture_output do
@@ -148,8 +148,8 @@ EOF
         output.should include("Success!")
       end
       
-      it "should run with_submodule_stashing" do
-        @controller.should_receive(:with_submodule_stashing)
+      it "should run with_submodule_cacheing" do
+        @controller.should_receive(:with_submodule_cacheing)
         capture_output { dispatch(:controller => "branch", :action => "merge") }
       end
     end

--- a/Support/spec/controllers/remote_controller_spec.rb
+++ b/Support/spec/controllers/remote_controller_spec.rb
@@ -67,8 +67,8 @@ describe RemoteController do
       @output.should include("Branch 'asdf': dc29d3d..05f9ad9")
     end
     
-    it "should with_submodule_stashing" do
-      @controller.should_receive(:with_submodule_stashing)
+    it "should with_submodule_cacheing" do
+      @controller.should_receive(:with_submodule_cacheing)
       capture_output { dispatch :controller => "remote", :action => "pull" }
     end
   end

--- a/Support/spec/lib/commands/submodule_spec.rb
+++ b/Support/spec/lib/commands/submodule_spec.rb
@@ -57,19 +57,19 @@ EOF
       @submodule.stub!(:url).and_return("git@url.com/path/to/repo.git")
     end
     
-    it "should stash" do
+    it "should cache" do
       File.should_receive(:exist?).with(@submodule.abs_path).and_return(true)
-      FileUtils.should_receive(:mkdir_p).with(File.join(@git.git_base, ".git/submodule_stash"))
-      FileUtils.should_receive(:rm_rf).with(@submodule.abs_stash_path)
-      FileUtils.should_receive(:mv).with(@submodule.abs_path, @submodule.abs_stash_path, :force => true)
-      @submodule.stash
+      FileUtils.should_receive(:mkdir_p).with(File.join(@git.git_base, ".git/submodule_cache"))
+      FileUtils.should_receive(:rm_rf).with(@submodule.abs_cache_path)
+      FileUtils.should_receive(:mv).with(@submodule.abs_path, @submodule.abs_cache_path, :force => true)
+      @submodule.cache
     end
     
     it "should restore when submodule isn't in working copy" do
       File.should_receive(:exist?).with(@submodule.abs_path).and_return(false)
-      File.should_receive(:exist?).with(@submodule.abs_stash_path).and_return(true)
+      File.should_receive(:exist?).with(@submodule.abs_cache_path).and_return(true)
       FileUtils.should_receive(:mkdir_p).with(File.dirname(@submodule.abs_path))
-      FileUtils.should_receive(:mv).with(@submodule.abs_stash_path, @submodule.abs_path, :force => true)
+      FileUtils.should_receive(:mv).with(@submodule.abs_cache_path, @submodule.abs_path, :force => true)
       @submodule.restore
     end
   end