svn-command 0.2.7 → 0.2.12

data/ProjectInfo.rb

@@ -5,7 +5,7 @@ module Project
   PrettyName    = "Enhanced Subversion Command"
   Name          = "svn-command"
   RubyForgeName = "svn-command"
-  Version       = "0.2.7"
+  Version       = "0.2.12"
   Specification = Gem::Specification.new do |s|
     s.name    = Project::Name
     s.summary = "A nifty wrapper command for Subversion's command-line svn client"
@@ -22,7 +22,6 @@ module Project
     s.add_dependency("colored")
     s.add_dependency("escape")
     s.add_dependency("facets")
-    s.add_dependency("extensions")
     s.add_dependency("qualitysmith_extensions")
     s.add_dependency("rscm")
     s.post_install_message = <<-End

data/Readme

@@ -1,9 +1,9 @@
 = <i>Enhanced Subversion command</i> -- an +svn+ command wrapper
 
-[*Environment*:]           Command line 
+[<b>Environment</b>:]      Command line (text based)
 [<b>Home page</b>:]        http://svn-command.rubyforge.org/
 [<b>Project site</b>:]     http://rubyforge.org/projects/svn-command
-[<b>Wiki</b>:]             http://wiki.qualitysmith.com/svn-command
+[<b>Gem install</b>:]      <tt>gem install svn-command</tt>
 [<b>Author</b>:]           Tyler Rick
 [<b>Copyright</b>:]        2007 QualitySmith, Inc.
 [<b>License</b>:]          {GNU General Public License}[http://www.gnu.org/copyleft/gpl.html]
@@ -127,7 +127,7 @@ Here are a couple things you might use it for:
   * Rather than looking at <tt>svn log -v</tt> (which can be _huge_) directly and then manually calculating revision numbers and doing things like <tt>svn diff -r1492:1493</tt> over and over, you can simply start up <tt>svn revisions</tt>, browse to the revision you're interested in using the Up/Down arrow keys, and press D to get a diff for the selected changeset.
 * <b>See what's been committed since the last public release</b>. So that you can list it in your release notes, for example...
 * <b>Review other people's code</b>. (There's even a mark-as-reviewed feature*, if you want to keep track of which revisions have been reviewed...)
-* <b>Searching for a change you know you've made</b> but don't remember what revision that was it. (Hint: Use the "grep this changeset" feature.)
+* <b>Search for a change you know you've _made_</b> but just don't remember what revision it was in. (Hint: Use the "grep this changeset" feature.)
 * Figure out what the <b>difference is between two branches</b>.
 
 Defaults to latest-first, but you can pass it the <tt>--forwards</tt> flag to browse from the other direction (start at the <i>oldest revision</i> and step forwards through time).
@@ -229,6 +229,14 @@ You can do this:
 or just this:
   svn edit_message
 
+== <tt>svn ignore</tt>
+
+If you want to add '*' to the list of ignored files for a directory, be sure to enclose the argument in single quotes (<tt>'</tt>) so that the shell doesn't expand the <tt>*</tt> symbol for you.
+
+Example:
+
+  svn ignore 'tmp/sessions/*'
+
 == <tt>svn move</tt>
 
 You can now do commands like this:
@@ -391,6 +399,19 @@ But... as with most things written in Ruby, it's all more about *productivity* t
 
 ==To do
 
+Calling "Extensions.anything" is stupid. Can't we just merge/extend/include the methods from Extensions into the Subversion module itself?
+
+Say you just did `svn mv base-suffix base-new_suffix`. Now say you want to commit that move without committing anything else in that dir.
+You'd think you could just do `svn ci base-*`, but no. That doesn't get base-suffix because it has been removed from the file system (and scheduled for deletion).
+Can we make it so a '*' (or any glob) (escaped so shell doesn't get it) actually looks at all files returned by `svn st` (which includes those scheduled for deletion, D) that match that glob rather than all files, rather than the glob that the *shell* would do?
+
+Say you cp'd a file A to B. You make some modifications to it and later decide to add it. Wouldn't it be nice if you could retroactively cause B to inherit the ancestry of A (as if you had svn cp'd it instead of cp'd it to begin with)?
+I propose a copy_ancestry_from / imbue_with_ancestry_from command, so that you can do svn copy_ancestry_from B A that does just that.
+Then you could also svn rm A and it would be (I think) completely equivalent to having done an svn mv A B in the first place.
+
+svn list_conflicts instead of:
+svn st --no-color | grep "^C"
+
 Take the best ideas from these and incorporate:
 * /usr/lib/ruby/gems/1.8/gems/rscm-0.5.1/lib/rscm/scm/subversion.rb
 * /usr/lib/ruby/gems/1.8/gems/lazysvn-0.1.3/lib/subversion.rb
@@ -399,13 +420,33 @@ Possibly switch to LazySvn.
 
 After you save/edit/set an svn:externals, it should try to automatically pretty up the margins/alignment for you.
 
-Done, I think:
-  Make sure to show errors! 
-
-  If there is an error during an update, such as this one:
-    Fetching external item into 'glass/rails_backend/vendor/plugins/our_extensions'
-    svn: REPORT request failed on '/!svn/vcc/default'
-    svn: Cannot replace a directory from within
-  it will not be displayed on screen. At least if it's an external that had the error.
+/usr/lib/ruby/gems/1.8/gems/piston-1.3.3/lib/piston/commands/import.rb has interesting way of parsing output from `svn info`
+        my_info = YAML::load(svn(:info, File.join(dir, '..')))
+        my_revision = YAML::load(svn(:info, my_info['URL']))['Revision']
 
 More at: http://wiki.qualitysmith.com/svn-command
+
+===Ideas from TortoiseSvn
+
+When you drag and drop one or more files to a WC directory, it prompts you with a context menu with these options:
+* svn move versioned files here
+* svn copy versioned files here
+* svn copy and rename versioned files here
+* svn add files to this WC
+* svn export to here
+* svn export all to here
+
+===Pick a better name!
+
+svn-command doesn't say anything to differentiate it from the built-in svn command. In fact, like I did just there, you can call the original 'svn' "the svn command" too, which makes the current name highly confusing.
+
+Word ideas to possibly incorporate:
+* improved
+* enhanced
+* wrapper
+* color
+* plus
+* more
+
+A play on the word sub?
+* 'subwrap'? Both a sub and wrap can be considered food items.

data/lib/svn-command/subversion.rb

@@ -43,6 +43,7 @@ module Subversion
   # If true, will print all commands to the screen before executing them.
   @@print_commands = false
   mattr_accessor :print_commands
+  mguard_method :print_commands!, :@@print_commands
 
   # Adds the given items to the repository. Items may contain wildcards.
   def self.add(*args)
@@ -324,7 +325,7 @@ module Subversion
     matches = info(path_or_url).match(/^Repository Root: (.+)/)
     matches && matches[1]
 
-     # It appears that we might need to use this old way (which looks at 'URL'), since there is actually a 
+     # It appears that we might need to use this old way (which looks at 'URL'), since there is actually a handy property called "Repository Root" that we can look at.
 #    base_url = nil    # needed so that base_url variable isn't local to loop block (and reset during next iteration)!
 #    started_using_dot_dots = false
 #    loop do
@@ -348,6 +349,39 @@ module Subversion
   def self.root_url(*args);        base_url(*args); end
   def self.repository_root(*args); base_url(*args); end
 
+  
+  def self.repository_uuid(path_or_url = './')
+    matches = info(path_or_url).match(/^Repository UUID: (.+)/)
+    matches && matches[1]
+  end
+
+  # By default, if you query a directory that is scheduled for addition but hasn't been committed yet (node doesn't have a UUID),
+  # then we will still return true, because it is *scheduled* to be under version control. If you want a stricter definition,
+  # and only want it to return true if the file exists in the *repository* (has a UUID)@ then pass strict = true
+  def self.under_version_control?(file = './', strict = false)
+    if strict
+      !!repository_uuid(file)
+    else # (scheduled_for_addition_counts_as_true)
+      !!url(file)
+    end
+  end
+  def self.working_copy_root(directory = './')
+    uuid = repository_uuid(directory)
+    return nil if uuid.nil?
+
+    loop do
+      # Keep going up, one level at a time, ...
+      new_directory = File.expand_path(File.join(directory, '..'))
+      new_uuid = repository_uuid(new_directory)
+
+      # Until we get back a uuid that is nil (it's not a working copy at all) or different (you can have a working copy A inside of a different WC B)...
+      break if new_uuid.nil? or new_uuid != uuid
+
+      directory = new_directory
+    end
+    directory
+  end
+
   # The location of the executable to be used
   def self.executable
     @@executable ||=
@@ -363,12 +397,6 @@ module Subversion
     #
   end
 
-  def self.print_commands_for(&block)
-    old_print_commands, @@print_commands = @@print_commands, true
-    yield
-    @@print_commands = old_print_commands
-  end
-
 protected
   def self.execute(*args)
     options = args.last.is_a?(Hash) ? args.pop : {}

data/lib/svn-command/subversion_extensions.rb

@@ -3,6 +3,8 @@
 gem 'colored'
 require 'colored'
 
+require 'facets/core/module/class_extension'
+
 class Array
   def to_regexp_char_class
     "[#{join('')}]"
@@ -70,73 +72,77 @@ module Subversion
     Uninteresting_status_flags = ["X", "W"]
     Status_flags = Interesting_status_flags | Uninteresting_status_flags
 
-    def self.status_lines_filter(input)
-      input = (input || "").reject { |line|
-        line =~ /^$/    # Blank lines
-      }.reject { |line|
-        line =~ /^#{Uninteresting_status_flags.to_regexp_char_class}/
-      }.join
-
-      before_externals, *externals = input.split(/^Performing status on external item at.*$/)
-
-      before_externals ||= ''
-      before_externals = before_externals.strip.colorize_svn_status_lines + "\n" if before_externals != ""
+    class_extension do  # These are actually class methods, but we have to do it this way so that the Subversion.extend(Subversion::Extensions) will also add these class methods to Subversion.
 
-      externals = externals.join.strip
-      externals = 
-        '_'*40 + ' externals '.underline + '_'*40 + "\n" +
-        externals.reject { |line|
-          line =~ /^Performing status on external item at/
+      def status_lines_filter(input)
+        input = (input || "").reject { |line|
+          line =~ /^$/    # Blank lines
         }.reject { |line|
+          line =~ /^#{Uninteresting_status_flags.to_regexp_char_class}/
+        }.join
+
+        before_externals, *externals = input.split(/^Performing status on external item at.*$/)
+
+        before_externals ||= ''
+        before_externals = before_externals.strip.colorize_svn_status_lines + "\n" if before_externals != ""
+
+        externals = externals.join.strip
+        externals = 
+          '_'*40 + ' externals '.underline + '_'*40 + "\n" +
+          externals.reject { |line|
+            line =~ /^Performing status on external item at/
+          }.reject { |line|
+            line =~ /^$/    # Blank lines
+          }.join.strip.colorize_svn_status_lines + "\n" if externals != ""
+          
+        before_externals +
+               externals
+      end
+
+      def update_lines_filter(input)
+        input.reject { |line|
           line =~ /^$/    # Blank lines
-        }.join.strip.colorize_svn_status_lines + "\n" if externals != ""
-        
-      before_externals +
-             externals
-    end
-
-    def self.update_lines_filter(input)
-      input.reject { |line|
-        line =~ /^$/    # Blank lines
-      }.reject { |line|
-        line =~ /^Fetching external item into/
-        # Eventually we may want it to include this whole block, but only iff there is something updated for this external.
-      }.reject { |line|
-        line =~ /^External at revision/
-      }.join.colorize_svn_update_lines
-      # Also get rid of all but one "At revision _."?
-    end
-
-    def self.unadded_lines_filter(input)
-      input.select { |line|
-        line =~ /^\?/
-      }.join
-    end
-    def self.unadded_filter(input)
-      unadded_lines_filter(input).map { |line|
-        # Just keep the filename part
-        line =~ /^\?\s+(.+)/
-        $1
-      }
-    end
-
-    def self.each_unadded(input)
-      unadded_filter(input).each { |line|
-        yield line
-      }
-    end
-
-    # This is just a wrapper for Subversion::diff that adds some color
-    def self.diff(*args)
-      Subversion::diff(*args).colorize_svn_diff.add_exit_code_error
-    end
-
-    # A wrapper for Subversion::revision_properties that formats it for display on srceen
-    def self.printable_revision_properties(rev)
-      Subversion::revision_properties(rev).map do |property|
-        "#{property.name.ljust(20)} = '#{property.value}'"
-      end.join("\n")
-    end
-
-  end
-end
+        }.reject { |line|
+          line =~ /^Fetching external item into/
+          # Eventually we may want it to include this whole block, but only iff there is something updated for this external.
+        }.reject { |line|
+          line =~ /^External at revision/
+        }.join.colorize_svn_update_lines
+        # Also get rid of all but one "At revision _."?
+      end
+
+      def unadded_lines_filter(input)
+        input.select { |line|
+          line =~ /^\?/
+        }.join
+      end
+      def unadded_filter(input)
+        unadded_lines_filter(input).map { |line|
+          # Just keep the filename part
+          line =~ /^\?\s+(.+)/
+          $1
+        }
+      end
+
+      def each_unadded(input)
+        unadded_filter(input).each { |line|
+          yield line
+        }
+      end
+
+      # This is just a wrapper for Subversion::diff that adds some color
+      def colorized_diff(*args)
+        Subversion::diff(*args).colorize_svn_diff.add_exit_code_error
+      end
+
+      # A wrapper for Subversion::revision_properties that formats it for display on srceen
+      def printable_revision_properties(rev)
+        Subversion::revision_properties(rev).map do |property|
+          "#{property.name.ljust(20)} = '#{property.value}'"
+        end.join("\n")
+      end
+
+    end # class_extension
+
+  end # module Extensions
+end # module Subversion

data/lib/svn-command/svn_command.rb

@@ -1,15 +1,19 @@
+# Tested by: ../../test/svn_command_test.rb
+
 require 'rubygems'
 
 gem 'facets', '>=1.8.51'
 #require 'facets/more/command'    # Not until they include my changes
-require 'facets/core/string/margin'
 require 'facets/core/kernel/require_local'
-require 'facets/core/array/select'      # select!
 require 'facets/core/kernel/with'       # returning
+require 'facets/core/enumerable/every'
+require 'facets/core/array/select'      # select!
+require 'facets/core/string/margin'
 require 'facets/core/string/lines'
 require 'facets/core/string/index_all'
 require 'facets/core/string/to_re'
 require 'facets/core/string/to_rx'
+require 'facets/core/symbol/to_proc'
 
 gem 'qualitysmith_extensions', '>=0.0.3'
 require 'qualitysmith_extensions/enumerable/enum'
@@ -17,12 +21,14 @@ require 'qualitysmith_extensions/array/expand_ranges'
 require 'qualitysmith_extensions/array/shell_escape'
 require 'qualitysmith_extensions/file_test/binary_file'
 require 'qualitysmith_extensions/console/command'
+require 'qualitysmith_extensions/module/attribute_accessors'
+#require 'qualitysmith_extensions/module/class_methods'
 
-require 'extensions/symbol'   # to_proc
 require 'English'
 require 'pp'
-require 'termios'
 require 'stringio'
+gem 'termios'
+require 'termios'
 gem 'colored'
 require 'colored'  # Lets us do "a".white.bold instead of "\033[1ma\033[0m"
 
@@ -34,8 +40,9 @@ begin
   # Set up termios so that it returns immediately when you press a key.
   # (http://blog.rezra.com/articles/2005/12/05/single-character-input)
   t = Termios.tcgetattr(STDIN)
+  save_terminal_attributes = t.dup
   t.lflag &= ~Termios::ICANON
-  Termios.tcsetattr(STDIN,0,t)
+  Termios.tcsetattr(STDIN, 0, t)
 rescue RuntimeError => exception    # Necessary for automated testing.
   if exception.message =~ /can't get terminal parameters/
     puts 'Warning: Terminal not found.'
@@ -45,6 +52,20 @@ rescue RuntimeError => exception    # Necessary for automated testing.
   end
 end
 
+begin  # Reset terminal_attributes
+
+module Kernel
+  # Simply to allow us to override it
+  # Should be renamed to exit_status maybe since it returns a Process::Status
+  def exit_code
+    $?
+  end
+end
+
+class Object
+  def nonnil?; !nil?; end
+end
+
 class String
   # Makes the first character bold and underlined. Makes the whole string of the given color.
   # :todo: Move out to extensions/console/menu_item
@@ -56,8 +77,9 @@ class String
     after  = self[index+1..-1].send(color)
     before.to_s + middle + after
   end
+  # Extracted so that we can override it for tests. Otherwise it will have a NoMethodError because $? will be nil because it will not have actually executed any commands.
   def add_exit_code_error
-    self << "Exited with error!".bold.red if !$?.success?
+    self << "Exited with error!".bold.red if !exit_code.success?
     self
   end
   def relativize_path
@@ -78,33 +100,60 @@ def confirm(question, options = ['Yes', 'No'])
   response
 end
 
-Subversion.extend(Subversion::Extensions)
+#Subversion.extend(Subversion::Extensions)
+module Subversion
+  include(Subversion::Extensions)
+end
 Subversion::color = true
 
 module Subversion
-  # Tested by: ../../test/svn_command_test.rb
   class SvnCommand < Console::Command
-    @@standard_remote_command_options = {
+  end
+end
+
+# Handle user preferences
+module Subversion
+  class SvnCommand
+    @@user_preferences = {}
+    mattr_accessor :user_preferences
+  end
+end
+if File.exists?(user_preference_file = "#{ENV['HOME']}/.svn-command.yml")
+  Subversion::SvnCommand.user_preferences = YAML::load(IO.read(user_preference_file)) || {}
+end
+
+module Subversion
+  class SvnCommand
+
+    # Constants
+    C_standard_remote_command_options = {
       [:__username] => 1,
       [:__password] => 1,
       [:__no_auth_cache] => 0,
       [:__non_interactive] => 0,
       [:__config_dir] => 1,
     }
-    mattr_reader :standard_remote_command_options
+    C_standard_commitable_command_options = {
+      [:_m, :__message] => 1,
+      [:_F, :__file] => 1,
+      [:__force_log] => 0,
+      [:__editor_cmd] => 1,
+      [:__encoding] => 1,
+    }
 
     # This shouldn't be necessary. Console::Command should allow introspection. But until such time...
     @@subcommand_list = [
       'each_unadded',
       'externals_items', 'externals_outline', 'externals_containers', 'edit_externals', 'externalize',
-      'ignore',
+      'ignore', 'edit_ignores',
       'revisions',
       'get_message', 'set_message', 'edit_message',
       'view_commits',
       'url',
-      'repository_root',
+      'repository_root', 'working_copy_root', 'repository_uuid',
       'latest_revision',
-      'delete_svn'
+      'delete_svn',
+      'fix_out_of_date_commit_state'
     ]
     mattr_reader :subcommand_list
 
@@ -186,8 +235,12 @@ module Subversion
       #     * Assume arity of 1. Then if it was really 0, it would pick up an extra arg that really wasn't supposed to be an arg for the *option*.
       # Ideally, we wouldn't be using option_missing at all because all options would be listed in the respective subcommand module...but for subcommands handled through method_missing, we don't have that option.
 
-      @passthrough_options << "#{option_name}" << args
-      @passthrough_options.flatten!
+      # The args will look like this, for example:
+      #   option_missing(-m, ["a multi-word message", "--something-else", "something else"])
+      # , so we need to be sure we wrap multi-word args in quotes as necessary. That's what the args.shell_escape does.
+
+      @passthrough_options << "#{option_name}" << args.shell_escape
+      @passthrough_options.flatten!  # necessary now that we have args.shell_escape ?
 
       return arity = args.size  # All of 'em
     end
@@ -220,19 +273,18 @@ module Subversion
           [:_N, :__non_recursive] => 1,
           [:__targets] => 1,
           [:__no_unlock] => 0,
-          [:_m, :__message] => 1,
-          [:_F, :__file] => 1,
-          [:__force_log] => 0,
-          [:__editor_cmd] => 1,
-          [:__encoding] => 1,
-        }.merge(SvnCommand::standard_remote_command_options), self
+        }.
+          merge(SvnCommand::C_standard_remote_command_options).
+          merge(SvnCommand::C_standard_commitable_command_options), self
       )
 
       # Use this flag if you don't want a commit notification to be sent out.
       def __skip_notification
         @skip_notification = true
       end
-      alias_method :__covert, :__skip_notification
+      alias_method :__covert,     :__skip_notification
+      alias_method :__minor_edit, :__skip_notification    # Like in MediaWiki. If you're just fixing a typo or something, then most people probably don't want to hear about it.
+      alias_method :__minor,      :__skip_notification
 
       # Use this flag if you are about to commit some code for which you know the tests aren't or (probaby won't) pass.
       # This *may* cause your continuous integration system to either skip tests for this revision or at least be a little more
@@ -248,28 +300,81 @@ module Subversion
       end
       alias_method :__expect_to_break_tests,            :__broken
       alias_method :__knowingly_committing_broken_code, :__broken
-    end
+
+      # Skips e-mail and marks reviewed=true
+      # Similar to the 'reviewed' command, which just marks reviewed=true
+      def __doesnt_need_review
+        @__doesnt_need_review = true
+      end
+
+      # :todo: svn doesn't allow you to commit changes to externals in the same transaction as your "main working copy", but we
+      # can provide the illusion that this is possible, by doing multiple commits, one for each working copy/external.
+      #
+      # When this option is used, the same commit message is used for all commits.
+      #
+      # Of course, this may not be what the user wants; the user may wish to specify a different commit message for the externals
+      # than for the "main working copy", in which case the user should not be using this option!
+      def __include_externals
+        @include_externals = true
+      end
+
+      # Causes blame/author for this commit/file to stay the same as previous revision of the file
+      # Useful to workaround bug where fixing indent and other inconsequential changes causes you to be displayed as the author if you do a blame, [hiding] the real author
+      def __shirk_blame
+        @shirk_blame = true
+      end
+
+    end #module Commit
+
     def commit(*args)
-      latest_rev_before_commit = Subversion.latest_revision if @broken || @skip_notification
+      directory = args.first || './'    # We can only pass one path to .latest_revision and .repository_root, so we'll just arbitrarily choose the first path. They should all be paths within the same repository anyway, so it shouldn't matter.
+      if @broken || @skip_notification
+        latest_rev_before_commit = Subversion.latest_revision(directory)
+        repository_root = Subversion.repository_root(directory)
+      end
 
-      Subversion.print_commands_for do
-        puts svn(:capture, "propset svn:skip_commit_notification_for_next_commit true --revprop -r #{latest_rev_before_commit}", :prepare_args => false)
+      Subversion.print_commands! do
+        puts svn(:capture, "propset svn:skip_commit_notification_for_next_commit true --revprop -r #{latest_rev_before_commit} #{repository_root}", :prepare_args => false)
       end if @skip_notification
       # :todo:
       # Add some logic to automatically skip the commit e-mail if the size of the files to be committed exceeds a threshold of __ MB.
       # (Performance idea: Only check the size of the files if svn st includes (bin)?)
 
+      # Have to use :system rather than :capture because they may not have specified a commit message, in which case it will open up an editor...
       svn(:system, 'commit', *(['--force-log'] + args))
 
+      puts ''.add_exit_code_error
+      return if !exit_code.success?
+
       # The following only works if we do :capture (`svn`), but that doesn't work so well (at all) if svn tries to open up an editor (vim),
       # which is what happens if you don't specify a message.:
       #   puts output = svn(:capture, 'commit', *(['--force-log'] + args))
       #   just_committed = (matches = output.match(/Committed revision (\d+)\./)) && matches[1]
 
-      Subversion.print_commands_for do
+      Subversion.print_commands! do
         puts svn(:capture, "propset code:broken true --revprop -r #{latest_rev_before_commit + 1}", :prepare_args => false)
       end if @broken
 
+      if @include_externals
+        #:todo:
+        #externals.each do |external|
+        #svn(:system, 'commit', *(['--force-log'] + args + external))
+        #end
+      end
+
+
+      # This should be disableable! ~/.svn-command ?
+      # http://svn.collab.net/repos/svn/trunk/doc/user/svn-best-practices.html:
+      #   After every svn commit, your working copy has mixed revisions. The things you just committed are now at the HEAD revision, and everything else is at an older revision.
+      #puts "Whenever you commit something, strangely, your working copy becomes out of date (as you can observe if you run svn info and look at the revision number). This is a problem for svn log, and piston, to name two applications. So we will now update '#{(args.every + '/..').join(' ').white.bold}' just to make sure they're not out of date..."
+      print ''.bold # Clear the bold flag that svn annoyingly sets
+      working_copy_root = Subversion.working_copy_root(directory).to_s
+      #response = confirm("Do you want to update #{working_copy_root.bold} now? (Any key other than y to skip) ")
+      #if response == 'y'
+        puts "Updating #{working_copy_root}..."
+      #end
+
+      puts Subversion.update_lines_filter( Subversion.update(*args) )
     end
 
     # Ideas:
@@ -284,11 +389,11 @@ module Subversion
 
       puts Subversion.export("#{dir}", "#{dir}.new").          # Exports (copies) the contents of working copy 'dir' (including your uncommitted changes, don't worry! ... and you'll get a chance to confirm before anything is deleted; but sometimes although it exports files that are scheduled for addition, they are no longer scheduled for addition in the new working copy, so you have to re-add them) to non-working-copy 'dir.new'
         add_exit_code_error 
-      return if !$?.success?
+      return if !exit_code.success?
 
       system("mv #{dir} #{dir}.backup")                        # Just in case something goes ary
       puts ''.add_exit_code_error
-      return if !$?.success?
+      return if !exit_code.success?
 
       puts "Restoring #{dir}..."
       Subversion.update dir                                    # Restore the directory to a pristine state so we will no longer get that annoying error
@@ -301,21 +406,26 @@ module Subversion
       system("cp -R #{dir}.new/. #{dir}/")
 
       # Assure the user one more time
-      puts Extensions.diff(dir)
+      puts Subversion.colorized_diff(dir)
+
+      puts "Please check the output of " + "svn st #{dir}.backup".blue.bold + " to check if any files were scheduled for addition. You will need to manually re-add these, as the export will have caused those files to lost their scheduling."
+      Subversion.print_commands! do
+        print Subversion.status_lines_filter( Subversion.status("#{dir}.backup") )
+        print Subversion.status_lines_filter( Subversion.status("#{dir}") )
+      end
 
       # Actually commit
       puts
       response = confirm("Are you ready to try the commit again now?")
       puts
       if response == 'y'
-        puts "Great. Go for it."
-        #Subversion.commit dir
+        puts "Great! Go for it. (I'd do it for you but I don't know what commit command you were trying to execute when the problem occurred.)"
       end
 
       # Clean up
       #puts
       #response = confirm("Do you want to delete array.backup array.new now?")
-      puts "Don't forget to delete array.backup array.new now!"
+      puts "Don't forget to " + "rm -rf #{dir}.backup #{dir}.new".blue.bold + " when you are done!"
       #rm_rf array.backup, array.new
       puts
     end
@@ -326,33 +436,42 @@ module Subversion
           [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
           [:__old] => 1,
           [:__new] => 0,
-          [:_N, :__non_recursive] => 1,
+          #[:_N, :__non_recursive] => 0,
           [:__diff_cmd] => 1,
           [:_x, :__extensions] => 1,      # :todo: should support any number of args??
           [:__no_diff_deleted] => 0,
           [:__notice_ancestry] => 1,
           [:__force] => 1,
-        }.merge(SvnCommand::standard_remote_command_options), self
+        }.merge(SvnCommand::C_standard_remote_command_options), self
       )
+
+      def __non_recursive
+        @non_recursive = true
+        @passthrough_options << '--non-recursive'
+      end
+      alias_method :_N, :__non_recursive
+
       def __ignore_externals
         @ignore_externals = true
       end
+      alias_method :_ie,             :__ignore_externals
+      alias_method :_skip_externals, :__ignore_externals
     end
 
     def diff(*directories)
       directories = ['./'] if directories.empty?
-      puts Extensions.diff(*(directories + @passthrough_options))
+      puts Subversion.colorized_diff(*(prepare_args(directories)))
 
       begin # Show diff for externals (if there *are* any and the user didn't tell us to ignore them)
         output = StringIO.new
         #paths = args.reject{|arg| arg =~ /^-/} || ['./']
         directories.each do |path|
           (Subversion.externals_items(path) || []).each do |item|
-            diff_output = Extensions.diff(item).strip
+            diff_output = Subversion.colorized_diff(item).strip
             unless diff_output == ""
               #output.puts '-'*100
               #output.puts item.ljust(100, ' ').black_on_white.bold.underline
-              output.puts item.ljust(100).black_on_white.bold
+              output.puts item.ljust(100).yellow_on_red.bold
               output.puts diff_output
             end
           end
@@ -363,7 +482,8 @@ module Subversion
           puts " Diff of externals (**don't forget to commit these too!**):".ljust(100, ' ').yellow_on_red.bold.underline
           puts output.string
         end
-      end unless @ignore_externals
+      end unless @ignore_externals || @non_recursive
+      # :todo: or @non_recursive (but that's currently a passthrough option that doesn't set @non_recursive)
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
@@ -422,16 +542,56 @@ End
           [:__incremental] => 0,
           [:__xml] => 0,
           [:__limit] => 1,
-        }.merge(SvnCommand::standard_remote_command_options), self
+        }.merge(SvnCommand::C_standard_remote_command_options), self
       )
     end
     def log(*args)
-      puts Subversion.log( @passthrough_options + args )
+      puts Subversion.log( prepare_args(args) )
       #svn :exec, *args
     end
 
     # Ideas:
     #   Just pass a number (5) and it will be treated as --limit 5 (unless File.exists?('5'))
+ 
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Mkdir
+      Console::Command.pass_through({
+          [:_q, :__quiet] => 0,
+        }.
+          merge(SvnCommand::C_standard_remote_command_options).
+          merge(SvnCommand::C_standard_commitable_command_options), self
+      )
+
+      # Make parent directories as needed. (Like the --parents option of GNU mkdir.)
+      def __parents; @create_parents = true; end
+      alias_method :_p, :__parents
+    end
+
+    def mkdir(*directories)
+      if @create_parents
+        directories.each do |directory|
+        
+          # :todo: change this so that it's guaranteed to have an exit condition; currently, can get into infinite loop
+          loop do
+            puts "Creating '#{directory}'"
+            FileUtils.mkdir_p directory   # Create it if it doesn't already exist
+            if Subversion.under_version_control?(File.dirname(directory))
+              # Yay, we found a working copy. Now we can issue an add command, from that directory, which will recursively add the
+              # (non-working copy) directories we've been creating along the way.
+              
+              #puts Subversion.add prepare_args([directory])
+              svn :system, 'add', *directory
+              break
+            else
+              directory = File.dirname(directory)
+            end
+          end
+        end
+      else
+        # Preserve default behavior.
+        svn :system, 'mkdir', *directories
+      end
+    end
 
     #-----------------------------------------------------------------------------------------------------------------------------
     module Move
@@ -439,13 +599,20 @@ End
           [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
           [:_q, :__quiet] => 0,
           [:__force] => 0,
-          [:_m, :__message] => 1,
-          [:_F, :__file] => 1,
-          [:__force_log] => 0,
-          [:__editor_cmd] => 1,
-          [:__encoding] => 1,
-        }.merge(SvnCommand::standard_remote_command_options), self
+        }.
+          merge(SvnCommand::C_standard_remote_command_options).
+          merge(SvnCommand::C_standard_commitable_command_options), self
       )
+
+      # If the directory specified by the destination path does not exist, it will `svn mkdir --parents` the directory for you to
+      # save you the trouble (and to save you from getting an error message!).
+      #
+      # For example, if you try to move file_name to dir1/dir2/new_file_name and dir1/dir2 is not under version control, then it
+      # will effectively do these commands:
+      #   svn mkdir --parents dir1/dir2
+      #   svn mv a dir1/dir2/new_file_name   # The command you were originally trying to do
+      def __parents; @create_parents = true; end
+      alias_method :_p, :__parents
     end
 
     # Unlike the built-in move, this one lets you list multiple source files 
@@ -453,19 +620,64 @@ End
     # or
     #   Source Destination
     def move(*args)
-      if args.length >= 3
-        destination = args.pop
+      destination = args.pop
+
+      # If the last character is a '/', then they obviously expect the destination to be a *directory*. Yet when I do this:
+      #   svn mv a b/
+      # and b doesn't exist,
+      #   it moves a (a file) to b as a file, rather than creating directory b/ and moving a to b/a.
+      # I find this default behavior less than intuitive, so I have "fixed" it here...
+      # So instead of seeing this:
+      #   A  b
+      #   D  a
+      # You should see this:
+      #   A  b
+      #   A  b/a
+      #   D  a
+      if destination[-1..-1] == '/'
+        if !File.exist?(destination[0..-2])
+          puts "Notice: It appears that the '" + destination.bold + "' directory doesn't exist. Would you like to create it now? Good..."
+          self.mkdir destination   # @create_parents flag will be reused there
+        elsif !File.directory?(destination[0..-2])
+          puts "Error".red.bold + ": It appears that '" + destination.bold + "' already exists but is not actually a directory. " +
+            "The " + 'destination'.bold + " must either be the path to a " + 'file'.underline + " that does " + 'not'.underline + " yet exist or the path to a " + 'directory'.underline + " (which may or may not yet exist)."
+          return
+        end
+      end
+
+      if @create_parents and !Subversion.under_version_control?(destination_dir = File.dirname(destination))
+        puts "Creating parent directory '#{destination_dir}'..."
+        self.mkdir destination_dir   # @create_parents flag will be reused there
+      end
+      if args.length >= 2
         sources = args
 
         sources.each do |source|
           puts filtered_svn('move', source, destination)
         end
       else
-        svn :exec, 'move', *args
+        svn :exec, 'move', *(args + [destination])
       end
     end
     alias_subcommand :mv => :move
 
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Import
+      Console::Command.pass_through({
+        [:_N, :__non_recursive] => 0,
+        [:_q, :__quiet] => 0,
+        [:__auto_props] => 0,
+        [:__no_auto_props] => 0,
+        }.
+          merge(SvnCommand::C_standard_remote_command_options).
+          merge(SvnCommand::C_standard_commitable_command_options), self
+      )
+    end
+    def import(*args)
+      p args
+      svn :exec, 'import', *(args)
+    end
+
     #-----------------------------------------------------------------------------------------------------------------------------
     module Status
       Console::Command.pass_through({
@@ -477,14 +689,11 @@ End
           [:__incremental] => 0,
           [:__xml] => 0,
           [:__ignore_externals] => 0,
-        }.merge(SvnCommand::standard_remote_command_options), self
+        }.merge(SvnCommand::C_standard_remote_command_options), self
       )
     end
     def status(*args)
-      #puts "in status(#{args.inspect})"
-      #puts "#{self}.@passthrough_options == #{@passthrough_options.inspect}"
-      #print Subversion::Extensions.status_lines_filter( Subversion.status(*(@passthrough_options + args)) )
-      print Subversion::Extensions.status_lines_filter( Subversion.status(*(@passthrough_options + args)) )
+      print Subversion.status_lines_filter( Subversion.status(*(prepare_args(args))) )
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
@@ -494,12 +703,24 @@ End
           [:_N, :__non_recursive] => 0,
           [:_q, :__quiet] => 0,
           [:__diff3_cmd] => 1,
-          [:__ignore_externals] => 0,
-        }.merge(SvnCommand::standard_remote_command_options), self
+          #[:__ignore_externals] => 0,
+        }.merge(SvnCommand::C_standard_remote_command_options), self
       )
+
+      def __ignore_externals;  @ignore_externals = true; end
+      def __include_externals; @ignore_externals = false; end
+      def __with_externals;    @ignore_externals = false; end
+
+      def ignore_externals?
+        @ignore_externals.nonnil? ?
+          @ignore_externals : 
+          (user_preferences['update'] && user_preferences['update']['ignore_externals'])
+      end
     end
+
     def update(*args)
-      puts Subversion::Extensions.update_lines_filter( Subversion.update(*prepare_args(args)) )
+      @passthrough_options << '--non-recursive' if ignore_externals?
+      puts Subversion.update_lines_filter( Subversion.update(*prepare_args(args)) )
     end
 
 
@@ -520,6 +741,25 @@ End
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
+
+    def under_version_control(*args)
+      puts Subversion.under_version_control?(*args)
+    end
+    alias_subcommand :under_version_control? => :under_version_control
+
+    # Returns root/base *path* for a working copy
+    def working_copy_root(*args)
+      puts Subversion.working_copy_root(*args)
+    end
+    alias_subcommand :root => :working_copy_root
+
+    # Returns the UUID for a working copy/URL
+    def repository_uuid(*args)
+      puts Subversion.repository_uuid(*args)
+    end
+    alias_subcommand :uuid => :repository_uuid
+
+    # Returns root repository *URL* for a working copy
     def repository_root(*args)
       puts Subversion.repository_root(*args)
     end
@@ -595,7 +835,7 @@ End
       catch :exit do
 
         $ignore_dry_run_option = true
-        Subversion::Extensions.each_unadded( Subversion.status(*args) ) do |file|
+        Subversion.each_unadded( Subversion.status(*args) ) do |file|
           $ignore_dry_run_option = false
           begin
             puts( ('-'*100).green )
@@ -628,6 +868,7 @@ End
               "Add".menu_item(:green) + ", " +
               "Delete".menu_item(:red) + ", " +
               "add to " + "svn:".yellow + "Ignore".menu_item(:yellow) + " property, " + 
+              "ignore ".yellow + "Contents".menu_item(:yellow) + " of directory, " + 
               "or " + "any other key".white.bold + " to do nothing > "
             )
             response = ""
@@ -761,11 +1002,10 @@ End
           end
           Subversion.externals_containers(directory).each do |external|
             puts external.to_s
-            command = "#{Subversion.executable} propedit svn:externals #{external.container_dir}"
-            #puts command
+            command = "propedit svn:externals #{external.container_dir}"
             begin
               response = confirm("Do you want to edit svn:externals for this directory?".black_on_white)
-              system command if response == 'y'
+              svn :system,  command if response == 'y'
             rescue Interrupt
               puts "\nGoodbye!"
               throw :exit
@@ -775,7 +1015,8 @@ End
           end
           puts 'Done'
         else
-          system "#{Subversion.executable} propedit svn:externals #{directory}"
+          #system "#{Subversion.executable} propedit svn:externals #{directory}"
+          svn :system, "propedit svn:externals #{directory}"
         end
       end # catch :exit
     end
@@ -811,6 +1052,14 @@ End
       Subversion.ignore(file)
     end
 
+    # Example:
+    #   svn edit_ignores tmp/sessions/
+    def edit_ignores(directory = './')
+      #puts Subversion.get_property("ignore", directory)
+      # If it's empty, ask them if they want to edit it anyway??
+
+      svn :system, "propedit svn:ignore #{directory}"
+    end
 
     #-----------------------------------------------------------------------------------------------------------------------------
     # Commit message retrieving/editing
@@ -868,7 +1117,7 @@ End
       args = ['propedit', '--revprop', property_name, directory]
       rev = @revision ? @revision : 'head'
       args.concat ['-r', rev]
-      Subversion.print_commands_for do
+      Subversion.print_commands! do
         svn :system, *args
       end
 
@@ -884,7 +1133,7 @@ End
         response = confirm("Are you sure you want to delete property #{property_name}".red.bold + "'? ")
         puts
         if response == 'y'
-          Subversion.print_commands_for do
+          Subversion.print_commands! do
             Subversion::delete_revision_property(property_name, rev)
           end
         end
@@ -906,9 +1155,14 @@ End
 
     #-----------------------------------------------------------------------------------------------------------------------------
     # Cause a working copy to cease being a working copy
-    def delete_svn
-      system('find -name .svn | xargs -n1 echo')
-      system('find -name .svn | xargs -n1 rm -r')
+    def delete_svn(directory = './')
+      puts "If you continue, all of the following directories/files will be deleted:"
+      system("find #{directory} -name .svn | xargs -n1 echo")
+      response = confirm("Do you wish to continue?")
+      puts
+      if response == 'y'
+        system("find #{directory} -name .svn | xargs -n1 rm -r")
+      end
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
@@ -1004,12 +1258,13 @@ End
 
         # Display the menu
         print(
+          "r#{rev}".magenta.on_blue.bold + ': ' + 
           'View this changeset'.menu_item(:cyan) + ', ' +
           'Diff against specific revision'.menu_item(:cyan, 'D') + ', ' +
           'Grep the changeset'.menu_item(:cyan, 'G') + ', ' +
           'List or '.menu_item(:magenta, 'L') + '' +
           'Edit revision properties'.menu_item(:magenta, 'E') + ', ' +
-          'svn Cat all files from revision'.menu_item(:cyan, 'C') + ', ' +
+          'svn Cat all files'.menu_item(:cyan, 'C') + ', ' +
           'grep the cat'.menu_item(:cyan, 'a') + ', ' + "\n  " +
           'mark as Reviewed'.menu_item(:green, 'R') + ', ' +
           'edit log Message'.menu_item(:yellow, 'M') + ', ' +
@@ -1037,20 +1292,23 @@ End
           end
 
           case response
-            when 'v'  # Diff
+            when 'v'  # View this changeset
               revs_to_compare = [other_rev, rev]
               puts "\n"*10
               puts((' '*100).green.underline)
               print "Diffing #{revs_to_compare.min}:#{revs_to_compare.max}... ".bold
               puts
               #Subversion.repository_root
-              SvnCommand.execute("diff #{directory} --ignore-externals -r #{revs_to_compare.min}:#{revs_to_compare.max}")
+              Subversion.print_commands! do
+                SvnCommand.execute("diff #{directory} --ignore-externals -r #{revs_to_compare.min}:#{revs_to_compare.max}")
+              end
+              show_revision_again = false
 
             when 'g'  # Grep the changeset
               # :todo; make it accept regexpes like /like.*this/im so you can make it case insensitive or multi-line
               revs_to_compare = [other_rev, rev]
               puts
-              print 'Grep for'.bold + ' (Regular expressions ' + 'like.*this'.bold.blue + ' are allowed, but not ' + '/like.*this/im'.bold.blue + '): '
+              print 'Grep for'.bold + ' (Case sensitive; Regular expressions ' + 'like.*this'.bold.blue + ' allowed, but not ' + '/like.*this/im'.bold.blue + ') (backspace not currently supported): '
               search_pattern = $stdin.gets.chomp.to_rx
               puts((' '*100).green.underline)
               puts "Searching `svn diff #{revs_to_compare.min}:#{revs_to_compare.max}` for #{search_pattern.to_s}... ".bold
@@ -1076,18 +1334,18 @@ End
 
             when 'l'  # List revision properties
               puts
-              puts Subversion::Extensions::printable_revision_properties(rev)
+              puts Subversion::printable_revision_properties(rev)
               show_revision_again = false
 
             when 'e'  # Edit revision property
               puts
-              puts Subversion::Extensions::printable_revision_properties(rev)
+              puts Subversion::printable_revision_properties(rev)
               puts "Warning: These properties are *not* under version control! Try not to permanently destroy anything *too* important...".red.bold
               puts "Note: If you want to *delete* a property, simply set its value to '' and it will be deleted (propdel) for you."
               print 'Which property would you like to edit'.bold + ' (backspace not currently supported)? '
               property_name = $stdin.gets.chomp
               unless property_name == ''
-                Subversion.print_commands_for do
+                Subversion.print_commands! do
                   @revision = rev
                   edit_revision_property(property_name, directory)
                 end
@@ -1110,16 +1368,18 @@ End
                                       # how to retrieve that (except by poking around in your ~/.subversion/ directory, but
                                       # that seems kind of rude...).
               puts "Marking as reviewed by '#{your_name}'..."
-              Subversion.print_commands_for do
+              Subversion.print_commands! do
                 puts svn(:capture, "propset code:reviewed '#{your_name}' --revprop -r #{rev}", :prepare_args => false)
                 # :todo: Maybe *append* to code:reviewed (,-delimited) rather than overwriting it?, in case there is a policy of requiring 2 reviewers or something
               end
+              show_revision_again = false
 
             when 'm'  # Edit log message
               puts
-              Subversion.print_commands_for do
+              Subversion.print_commands! do
                 SvnCommand.execute("edit_message -r #{rev}")
               end
+              show_revision_again = false
 
             when "\e[A" # Up
               i = revision_ids.index(rev)
@@ -1192,6 +1452,7 @@ End
       svn(:capture, *args).add_exit_code_error
     end
 
+    # Removes nil elements, converts to strings, and adds any pass-through args that may have been provided.
     def prepare_args(args)
       args.compact!       # nil elements spell trouble
       args.map!(&:to_s)   # shell_escape doesn't like Fixnums either
@@ -1203,3 +1464,8 @@ End
     end
   end
 end
+
+ensure
+  # Set terminal_attributes back to how we found them...
+  Termios.tcsetattr(STDIN, 0, save_terminal_attributes)
+end