subwrap 0.3.5

data/lib/subwrap/subversion_extensions.rb

@@ -0,0 +1,148 @@
+# Tested by: ../../test/subversion_extensions_test.rb
+
+gem 'colored'
+require 'colored'
+
+require 'facets/core/module/class_extension'
+
+class Array
+  def to_regexp_char_class
+    "[#{join('')}]"
+  end
+end
+
+class String
+  def colorize_svn_question_mark; self.yellow.bold; end
+  def colorize_svn_add;           self.green.bold; end
+  def colorize_svn_modified;      self.cyan.bold; end
+  def colorize_svn_updated;       self.yellow.bold; end
+  def colorize_svn_deleted;       self.magenta.bold; end
+  def colorize_svn_conflict;      self.red.bold; end
+  def colorize_svn_tilde;         self.red.bold; end
+  def colorize_svn_exclamation;   self.red.bold; end
+
+  def colorize_svn_status_code
+    if Subversion.color
+      self.gsub('?') { $&.colorize_svn_question_mark }.
+           gsub('A') { $&.colorize_svn_add }.
+           gsub('M') { $&.colorize_svn_modified }.
+           gsub('D') { $&.colorize_svn_deleted }.
+           gsub('C') { $&.colorize_svn_conflict }.
+           gsub('~') { $&.colorize_svn_tilde }.
+           gsub('!') { $&.colorize_svn_exclamation }
+    else
+      self
+    end
+  end
+  def colorize_svn_status_lines
+    if Subversion.color
+      self.gsub(/^ *([^ ])\s/) { $&.colorize_svn_status_code }
+    else
+      self
+    end
+  end
+  def colorize_svn_update_lines
+    if Subversion.color
+      self.gsub(/^ *U\s/)  { $&.colorize_svn_updated }.
+           gsub(/^ *A\s/)  { $&.colorize_svn_add }.
+           gsub(/^ *M\s/)  { $&.colorize_svn_modified }.
+           gsub(/^ *D\s/)  { $&.colorize_svn_deleted }.
+           gsub(/^ *C\s/)  { $&.colorize_svn_conflict }
+    else
+      self
+    end
+  end
+  def colorize_svn_diff
+    if Subversion.color
+      self.gsub(/^(Index: )(.*)$/) { $2.ljust(100).black_on_white}.
+           gsub(/^=+\n/, '') 
+    else
+      self
+    end
+  end
+end
+
+
+# These are methods used by the SvnCommand for filtering and whatever else it needs...
+# It could probably be moved into SvnCommand, but I thought it might be good to at least make it *possible* to use them apart from SvnCommand.
+# Rename to Subversion::Filters ? Then each_unadded would be an odd man out.
+module Subversion
+  module Extensions
+    Interesting_status_flags = ["M", "A", "D", "?"]
+    Uninteresting_status_flags = ["X", "W"]
+    Status_flags = Interesting_status_flags | Uninteresting_status_flags
+
+    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.
+
+      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
+        }.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/subwrap/svn_command.rb

@@ -0,0 +1,1568 @@
+# 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/kernel/require_local'
+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'
+require 'facets/core/kernel/in'
+
+gem 'quality_extensions', '>=0.0.3'
+require 'quality_extensions/enumerable/enum'
+require 'quality_extensions/array/expand_ranges'
+require 'quality_extensions/array/shell_escape'
+require 'quality_extensions/file_test/binary_file'
+require 'quality_extensions/console/command'
+require 'quality_extensions/module/attribute_accessors'
+#require 'quality_extensions/module/class_methods'
+
+require 'English'
+require 'pp'
+require 'stringio'
+
+gem 'colored'
+require 'colored'  # Lets us do "a".white.bold instead of "\033[1ma\033[0m"
+
+require_local '../../ProjectInfo'
+require_local 'subversion'
+require_local 'subversion_extensions'
+
+
+begin
+  gem 'termios'
+  require 'termios'
+  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)
+
+    # Set terminal_attributes back to how we found them...
+    at_exit { Termios.tcsetattr(STDIN, 0, save_terminal_attributes) }
+  rescue RuntimeError => exception    # Necessary for automated testing.
+    if exception.message =~ /can't get terminal parameters/
+      puts 'Warning: Terminal not found.'
+      $interactive = false
+    else
+      raise
+    end
+  end
+  $termios_loaded = true
+rescue Gem::LoadError
+  $termios_loaded = false
+end
+
+
+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 IO
+  # Gets a single character, as a string.
+  # Adjusts for the different behavior of getc if we are using termios to get it to return immediately when you press a single key
+  # or if they are not using that behavior and thus have to press Enter after their single key.
+  def getch
+    response = getc
+    if !$termios_loaded
+      next_char = getc
+      new_line_characters_expected = ["\n"]
+      #new_line_characters_expected = ["\n", "\r"] if windows?
+      if next_char.chr.in?(new_line_characters_expected)
+        # Eat the newline character
+      else
+        # Don't eat it
+        # (This case is necessary, for escape sequences, for example, where they press only one key, but it produces multiple characters.)
+        $stdin.ungetc(next_char)
+      end
+    end
+    response.chr
+  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
+  def menu_item(color = :white, letter = self[0..0], which_occurence = 0)
+    index = index_all(/#{letter}/)[which_occurence]
+    raise "Could not find a #{which_occurence}th occurence of '#{letter}' in string '#{self}'" if index.nil?
+    before = self[0..index-1].send(color) unless index == 0
+    middle = self[index..index].send(color).bold.underline
+    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 !exit_code.success?
+    self
+  end
+  def relativize_path
+    self.gsub(File.expand_path(FileUtils.getwd) + '/', '')   # Simplify the directory by removing the working directory from it, if possible
+  end
+  def highlight_occurences(search_pattern, color = :red)
+    self.gsub(search_pattern) { $&.send(color).bold }
+  end
+end
+def confirm(question, options = ['Yes', 'No'])
+  print question + " " +
+    "Yes".menu_item(:red) + ", " +
+    "No".menu_item(:green) + 
+    " > "
+  response = ''
+  # Currently allow user to press Enter to accept the default.
+  response = $stdin.getch.downcase while !['y', 'n', "\n"].include?(begin response.downcase!; response end)
+  response
+end
+
+#Subversion.extend(Subversion::Extensions)
+module Subversion
+  include(Subversion::Extensions)
+end
+Subversion::color = true
+
+module Subversion
+  class SvnCommand < Console::Command
+  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']}/.subwrap.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,
+    }
+    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', 'edit_ignores',
+      'revisions',
+      'get_message', 'set_message', 'edit_message',
+      'view_commits',
+      'url',
+      'repository_root', 'working_copy_root', 'repository_uuid',
+      'latest_revision',
+      'delete_svn',
+      'fix_out_of_date_commit_state'
+    ]
+    mattr_reader :subcommand_list
+
+    def initialize(*args)
+      @passthrough_options = []
+      super
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Global options
+    
+    global_option :__no_color, :__dry_run, :__debug, :__print_commands
+    def __no_color
+      Subversion::color = false
+    end
+    def __debug
+      $debug = true
+    end
+    def __dry_run
+      Subversion::dry_run = true
+    end
+
+    def __print_commands
+      Subversion::print_commands = true
+    end
+    alias_method :__show_commands,  :__print_commands
+    # Don't want to hide/conflict with svn's own -v/--verbose flag, so using capital initial letter
+    alias_method :_V,               :__print_commands
+    alias_method :__Verbose,        :__print_commands
+
+    # Usually most Subversion commands are recursive and all-inclusive. This option adds file *exclusion* to most of Subversion's commands.
+    # Use this if you want to commit (/add/etc.) everything *but* a certain file or set of files
+    #   svn commit dir1 dir2 --except dir1/not_ready_yet.rb
+    def __except
+      # We'll have to use a FileList to do this. This option will remove all file arguments, put them into a FileList as inclusions, 
+      # add the exclusions, and then pass the resulting list of files on to the *actual* svn command.
+      # :todo:
+    end
+    alias_method :__exclude, :__except
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Default/dynamic behavior
+    
+    # Any subcommands that we haven't implemented here will simply be passed on to the built-in svn command.
+    # :todo: Distinguish between subcommand_missing and method_missing !
+    #   Currently, for example, if as isn't defined, this: puts Subversion.externalize(repo_path, {:as => as })
+    #   will call method_missing and try to run `svn as`, which of course will fail (without a sensible relevant error)...
+    #   I think we should probably just have a separate subcommand_missing, like we already have a separate option_missing !!!
+    #   Even a simple type (sss instead of ss) causes trouble... *this* was causing a call to "/usr/bin/svn new_messsage" -- what huh??
+    #      def set_message(new_message = nil)
+    #        args << new_messsage if new_message
+    def method_missing(subcommand, *args)
+      #puts "method_missing(#{subcommand}, #{args.inspect})"
+      svn :exec, subcommand, *args
+    end
+    # This is here solely to allow subcommandless commands like `svn --version`
+    def default()
+      svn :exec
+    end
+
+    def option_missing(option_name, args)
+      #puts "#{@subcommand} defined? #{@subcommand_is_defined}"
+      if !@subcommand_is_defined
+        # It's okay to use this for pass-through subcommands, because we just pass all options/arguments verbatim anyway...
+        #puts "option_missing(#{option_name}, #{args.inspect})"
+      else
+        # But for subcommands that are defined here, we should know better! All valid options should be explicitly listed!
+        raise UnknownOptionError.new(option_name)
+      end
+
+      # The following is necessary because we really don't know the arity (how many subsequent tokens it should eat) of the option -- we don't know anything about the options, in fact; that's why we've landed in option_missing.
+      # This is kind of a hokey solution, but for any unrecognized options/args (which will be *all* of them unless we list the available options in the subcommand module), we just eat all of the args, store them in @passthrough_options, and later we will add them back on.
+      # What's annoying about it this solution is that *everything* after the first unrecognized option comes in as args, even if they are args for the subcommand and not for the *option*!
+      # But...it seems to work to just pretend they're options.
+      # It seems like this is mostly a problem for *wrappers* that try to use Console::Command. Sometimes you just want to *pass through all args and options* unchanged and just filter the output somehow.
+      # Command doesn't make that super-easy though. If an option (--whatever) isn't defined, then the only way to catch it is in option_missing. And since we can't the arity unless we enumerate all options, we have to hokily treat the first option as having unlimited arity.
+      #   Alternatives considered: 
+      #     * Assume arity of 0. Then I'm afraid it would extract out all the option flags and leave the args that were meant for the args dangling there out of order ("-r 1 -m 'hi'" => "-r -m", "1 'hi'")
+      #     * 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.
+
+      # 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
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Built-in commands (in alphabetical order)
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Add
+      Console::Command.pass_through({
+        [:__targets] => 1,
+        [:_N, :__non_recursive] => 0,
+        [:_q, :__quiet] => 0,
+        [:__config_dir] => 1,
+        [:__force] => 0,
+        [:__no_ignore] => 0,
+        [:__auto_props] => 0,
+        [:__no_auto_props] => 0,
+      }, self)
+    end
+    def add(*args)
+      #puts "add #{args.inspect}"
+      svn :exec, 'add', *args
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Commit
+      Console::Command.pass_through({
+          [:_q, :__quiet] => 0,
+          [:_N, :__non_recursive] => 1,
+          [:__targets] => 1,
+          [:__no_unlock] => 0,
+        }.
+          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 :__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
+      # *leniant* towards you (a slap on the wrist instead of a public flogging, perhaps) when it runs the tests and finds that
+      # they *are* failing.
+      # You should probably only do this if you are planning on making multiple commits in rapid succession (sometimes Subversion
+      # forces you to do an intermediate commit in order to move something that's already been scheduled for a move or somethhing,
+      # for example). If things will be broken for a while, consider starting a branch for your changes and merging the branch
+      # back into trunk only when you've gotten the code stable/working again.
+      # (See http://svn.collab.net/repos/svn/trunk/doc/user/svn-best-practices.html)
+      def __broken
+        @broken = true
+      end
+      alias_method :__expect_to_break_tests,            :__broken
+      alias_method :__knowingly_committing_broken_code, :__broken
+
+      # 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)
+      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! 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! 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! ~/.subwrap ?
+      # 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} (non-recursively)..."
+      #end
+      #puts Subversion.update_lines_filter( Subversion.update(*args) )
+    end
+
+    # Ideas:
+    # * look for .svn-commit files within current tree and if one is found, show what's in it and ask 
+    #   "Found a commit message from a previous failed commit. {preview} Do you want to (u)se this message for the current commit, or (d)elete it?"
+
+    # A fix for this annoying problem that I seem to come across all too frequentrly:
+    #   svn: Commit failed (details follow):
+    #   svn: Your file or directory 'whatever.rb' is probably out-of-date
+    def fix_out_of_date_commit_state(dir)
+      dir = $1 if dir =~ %r|^(.*)/$|                           # Strip trailing slash.
+
+      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 !exit_code.success?
+
+      system("mv #{dir} #{dir}.backup")                        # Just in case something goes ary
+      puts ''.add_exit_code_error
+      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
+
+      # Assure the user that dir.new really does have your latest changes
+      #puts "Here's a diff. Your changes/additions will be in the *right* (>) file."
+      #system("diff #{dir}.backup #{dir}")
+
+      # Merge those latest changes back into the pristine working copy
+      system("cp -R #{dir}.new/. #{dir}/")
+
+      # Assure the user one more time
+      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. (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 " + "rm -rf #{dir}.backup #{dir}.new".blue.bold + " when you are done!"
+      #rm_rf array.backup, array.new
+      puts
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Diff
+      Console::Command.pass_through({
+          [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
+          [:__old] => 1,
+          [:__new] => 0,
+          #[:_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::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 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 = 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).yellow_on_red.bold
+              output.puts diff_output
+            end
+          end
+        end
+        unless output.string == ""
+          #puts '='*100
+          puts (' '*100).yellow.underline
+          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 || @non_recursive
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Help
+      Console::Command.pass_through({
+        [:__version] => 0,
+        [:_q, :__quiet] => 0,
+        [:__config_dir] => 1,
+      }, self)
+    end
+    def help(subcommand = nil)
+      case subcommand
+        when "externals"
+          puts %Q{
+                 | externals (ext): Lists all externals in the given working directory.
+                 | usage: externals [PATH]
+                 }.margin
+          # :todo: Finish...
+
+        when nil
+          puts "You are using " + 
+               's'.green.bold + 'v'.cyan.bold + 'n'.magenta.bold + '-' + 'c'.red.bold + 'o'.cyan.bold + 'm'.blue.bold + 'm'.yellow.bold + 'a'.green.bold + 'n'.white.bold + 'd'.green.bold + ' version ' + Project::Version
+               ", a colorful, useful replacement/wrapper for the standard svn command."
+          puts "subwrap is installed at: " + $0.bold
+          puts "You may bypass this wrapper by using the full path to svn: " + Subversion.executable.bold
+          puts
+          puts Subversion.help(subcommand).gsub(<<End, '')
+
+Subversion is a tool for version control.
+For additional information, see http://subversion.tigris.org/
+End
+
+          puts
+          puts 'Subcommands added by subwrap (refer to '.green.underline + 'http://subwrap.rubyforge.org/'.white.underline + ' for usage details):'.green.underline
+          @@subcommand_list.each do |subcommand|
+            aliases_list = subcommand_aliases_list(subcommand.option_methodize.to_sym)
+            aliases_list = aliases_list.empty? ? '' : ' (' + aliases_list.join(', ') + ')'
+            puts '   ' + subcommand + aliases_list
+          end
+          #p subcommand_aliases_list(:edit_externals)
+
+        else
+          #puts "help #{subcommand}"
+          puts Subversion.help(subcommand)
+      end
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Log
+      Console::Command.pass_through({
+          [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
+          [:_q, :__quiet] => 0,
+          [:_v, :__verbose] => 0,
+          [:__targets] => 1,
+          [:__stop_on_copy] => 0,
+          [:__incremental] => 0,
+          [:__xml] => 0,
+          [:__limit] => 1,
+        }.merge(SvnCommand::C_standard_remote_command_options), self
+      )
+    end
+    def log(*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
+      Console::Command.pass_through({
+          [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
+          [:_q, :__quiet] => 0,
+          [:__force] => 0,
+        }.
+          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
+
+    def move(*args)
+      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
+
+      # Unlike the built-in move, this one lets you list multiple source files 
+      #   Source... DestinationDir
+      # or
+      #   Source Destination
+      # Useful when you have a long list of files you want to move, such as when you are using wild-cards. Makes commands like this possible:
+      #   svn mv source/* dest/
+      if args.length >= 2
+        sources = args
+
+        sources.each do |source|
+          puts filtered_svn('move', source, destination)
+        end
+      else
+        svn :exec, 'move', *(args + [destination])
+      end
+    end
+    alias_subcommand :mv => :move
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Copy
+      Console::Command.pass_through({
+          [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
+          [:_q, :__quiet] => 0,
+          [:__force] => 0,
+        }.
+          merge(SvnCommand::C_standard_remote_command_options).
+          merge(SvnCommand::C_standard_commitable_command_options), self
+      )
+    end
+
+    def copy(*args)
+      destination = args.pop
+
+      # Unlike the built-in copy, this one lets you list multiple source files 
+      #   Source... DestinationDir
+      # or
+      #   Source Destination
+      # Useful when you have a long list of files you want to copy, such as when you are using wild-cards. Makes commands like this possible:
+      #   svn cp source/* dest/
+      if args.length >= 2
+        sources = args
+
+        sources.each do |source|
+          puts filtered_svn('copy', source, destination)
+        end
+      else
+        svn :exec, 'copy', *(args + [destination])
+      end
+    end
+    alias_subcommand :cp => :copy
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    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({
+          [:_u, :__show_updates] => 0,
+          [:_v, :__verbose] => 0,
+          [:_N, :__non_recursive] => 0,
+          [:_q, :__quiet] => 0,
+          [:__no_ignore] => 0,
+          [:__incremental] => 0,
+          [:__xml] => 0,
+          [:__ignore_externals] => 0,
+        }.merge(SvnCommand::C_standard_remote_command_options), self
+      )
+    end
+    def status(*args)
+      print Subversion.status_lines_filter( Subversion.status(*(prepare_args(args))) )
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Update
+      Console::Command.pass_through({
+          [:_r, :__revision] => 1,        # :todo: support "{" DATE "}" format
+          [:_N, :__non_recursive] => 0,
+          [:_q, :__quiet] => 0,
+          [:__diff3_cmd] => 1,
+          #[:__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
+      alias_method :_ie,             :__ignore_externals
+      alias_method :_skip_externals, :__ignore_externals
+
+      def ignore_externals?
+        @ignore_externals.nonnil? ?
+          @ignore_externals : 
+          (user_preferences['update'] && user_preferences['update']['ignore_externals'])
+      end
+
+      # Duplicated with Diff
+      def __non_recursive
+        @non_recursive = true
+        @passthrough_options << '--non-recursive'
+      end
+      alias_method :_N, :__non_recursive
+
+    end
+
+    def update(*args)
+      @passthrough_options << '--ignore-externals' if ignore_externals?
+      Subversion.print_commands! do   # Print the commands and options used so they can be reminded that they're using user_preferences['update']['ignore_externals']...
+        puts Subversion.update_lines_filter( Subversion.update(*prepare_args(args)) )
+      end
+    end
+
+
+
+
+
+
+
+
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Custom subcommands
+    #-----------------------------------------------------------------------------------------------------------------------------
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    def url(*args)
+      puts Subversion.url(*args)
+    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
+    alias_subcommand :base_url => :repository_root
+    alias_subcommand :root_url => :repository_root
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    def latest_revision(*args)
+      puts Subversion.latest_revision
+    end
+    alias_subcommand :last_revision => :latest_revision
+    alias_subcommand :head          => :latest_revision
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+
+    # *Experimental*
+    #
+    # Combine commit messages / diffs for the given range for the given files. Gives one aggregate diff for the range instead of many individual diffs.
+    #
+    # Could be useful for code reviews?
+    #
+    # Pass in a list of revisions/revision ranges ("134", "134:136", "134-136", and "134-136 139" are all valid)
+    #
+    module ViewCommits
+      def _r(*revisions)
+        # This is necessary so that the -r option doesn't accidentally eat up an arg that wasn't meant to be a revision (a filename, for instance). The only problem with this is if there's actully a filename that matches these patterns! (But then we could just re-order ars.)
+        revisions.select! do |revision|
+          revision =~ /\d+|\d+:\d+/
+        end
+        @revisions = revisions
+        @revisions.size
+      end
+    end
+    def view_commits(path = "./")
+      if @revisions.nil?
+        raise "-r (revisions) option is mandatory"
+      end
+      $ignore_dry_run_option = true
+      base_url = Subversion.base_url(path)
+      $ignore_dry_run_option = false
+      #puts "Base URL: #{base_url}"
+      revisions = self.class.parse_revision_ranges(@revisions)
+      revisions.each do |revision|
+        puts Subversion.log("-r #{revision} -v #{base_url}")
+      end
+      
+      puts Subversion.diff("-r #{revisions.first}:#{revisions.last} #{path}")
+      #/usr/bin/svn diff http://code.qualitysmith.com/gemables/subversion@2279 http://code.qualitysmith.com/gemables/subwrap@2349 --diff-cmd colordiff
+
+    end
+    alias_subcommand :code_review => :view_commits
+
+    def SvnCommand.parse_revision_ranges(revisions_array)
+      revisions_array.map do |item|
+        case item
+          when /(\d+):(\d+)/
+            ($1.to_i .. $2.to_i)
+          when /(\d+)-(\d+)/
+            ($1.to_i .. $2.to_i)
+          when /(\d+)\.\.(\d+)/
+            ($1.to_i .. $2.to_i)
+          when /\d+/
+            item.to_i
+          else
+            raise "Item in revisions_array had an unrecognized format: #{item}"
+        end
+      end.expand_ranges
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Goes through each "unadded" file (each file reporting a status of <tt>?</tt>) reported by <tt>svn status</tt> and asks you what you want to do with them (add, delete, or ignore)
+    def each_unadded(*args)
+      catch :exit do
+
+        $ignore_dry_run_option = true
+        Subversion.each_unadded( Subversion.status(*args) ) do |file|
+          $ignore_dry_run_option = false
+          begin
+            puts( ('-'*100).green )
+            puts "What do you want to do with '#{file.white.underline}'?".white.bold
+            begin
+              if !File.exist?(file)
+                raise "#{file} doesn't seem to exist -- even though it was reported by svn status"
+              end
+              if File.file?(file)
+                if FileTest.binary_file?(file)
+                  puts "(Binary file -- cannot show preview)".bold
+                else
+                  puts "File contents:"
+                  # Only show the first x bytes so that we don't accidentally dump the contens of some 20 GB log file to screen...
+                  contents = File.read(file, bytes_threshold = 5000) || ''
+                  max_lines = 55
+                  contents.lines[0..max_lines].each {|line| puts line}
+                  puts "..." if contents.length >= bytes_threshold          # So they know that there may be *more* to the file than what's shown
+                end
+              elsif File.directory?(file)
+                puts "Directory contains:"
+                Dir.new(file).reject {|f| ['.','..'].include? f}.each do |f|
+                  puts f
+                end
+              else
+                raise "#{file} is not a file or directory -- what *is* it then???"
+              end
+            end
+            print(
+              "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 = ""
+            response = $stdin.getch.downcase # while !['a', 'd', 'i', "\n"].include?(begin response.downcase!; response end)
+
+            case response
+              when 'a'
+                print "\nAdding... "
+                Subversion.add file
+                puts
+              when 'd'
+                puts
+
+                response = ""
+                if File.directory?(file)
+                  response = confirm("Are you pretty much " + "SURE".bold + " you want to '" + "rm -rf #{file}".red.bold + "'? ")
+                else
+                  response = "y"
+                end
+
+                if response == 'y'
+                  print "\nDeleting... "
+                  FileUtils.rm_rf file
+                  puts
+                else
+                  puts "\nI figured as much!"
+                end
+              when 'i'
+                print "\nIgnoring... "
+                Subversion.ignore file
+                puts
+              else
+                # Skip / Do nothing with this file
+                puts " (Skipping...)"
+            end
+          rescue Interrupt
+            puts "\nGoodbye!"
+            throw :exit
+          end
+        end # each_unadded
+
+      end # catch :exit
+    end
+    alias_subcommand :eu => :each_unadded
+    alias_subcommand :unadded => :each_unadded
+
+
+
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Externals-related commands
+    
+    # Prints out all the externals *items* for the given directory. These are the actual externals listed in an svn:externals property.
+    # Example:
+    #   vendor/a
+    #   vendor/b
+    # Where 'vendor' is an ExternalsContainer containing external items 'a' and 'b'.
+    # (Use the -o/--omit-repository-path option if you just want the external paths/names without the repository paths)
+    module ExternalsItems
+      def __omit_repository_path
+        @omit_repository_path = true
+      end
+      alias_method :__omit_repository, :__omit_repository_path
+      alias_method :_o,                :__omit_repository_path
+      alias_method :_name_only,        :__omit_repository_path
+    end
+    def externals_items(directory = "./")
+      longest_path_name = 25
+
+      externals_structs = Subversion.externals_containers(directory).map do |external|
+        returning(
+          external.entries_structs.map do |entry|
+              Struct.new(:path, :repository_path).new(
+                File.join(external.container_dir, entry.name).relativize_path,
+                entry.repository_path
+              )
+            end
+        ) do |entries_structs|
+          longest_path_name = 
+            [
+              longest_path_name,
+              entries_structs.map { |entry|
+                entry.path.size
+              }.max.to_i
+            ].max
+        end
+      end
+
+      puts externals_structs.map { |entries_structs|
+        entries_structs.map { |entry|
+          entry.path.ljust(longest_path_name + 1) +
+            (@omit_repository_path ? '' : entry.repository_path)
+        }
+      }
+      puts "(Tip: Also consider using svn externals_outline. Or use the -o/--omit-repository-path option if you just want a list of the paths that are externalled (without the repository URLs that they come from)".magenta unless @omit_repository_path
+    end
+    alias_subcommand :ei             => :externals_items
+    alias_subcommand :externals_list => :externals_items
+    alias_subcommand :el             => :externals_items
+    alias_subcommand :externals      => :externals_items
+    alias_subcommand :e              => :externals_items
+
+
+    # For every directory that has the svn:externals property set, this prints out the container name and then lists the contents of its svn:externals property (dir, URL) as a bulleted list
+    def externals_outline(directory = "./")
+      puts Subversion.externals_containers(directory).map { |external|
+        external.to_s.relativize_path
+      }
+    end
+    alias_subcommand :e_outline => :externals_outline
+    alias_subcommand :eo        => :externals_outline
+
+    # Lists *directories* that have the svn:externals property set.
+    def externals_containers(directory = "./")
+      puts Subversion.externals_containers(directory).map { |external|
+        external.container_dir
+      }
+    end
+    alias_subcommand :e_containers => :externals_containers
+
+    def edit_externals(directory = nil)
+      catch :exit do
+        if directory.nil? || !Subversion::ExternalsContainer.new(directory).has_entries?
+          if directory.nil?
+            puts "No directory specified. Editing externals for *all* externals dirs..."
+            directory = "./"
+          else
+            puts "Editing externals for *all* externals dirs..."
+          end
+          Subversion.externals_containers(directory).each do |external|
+            puts external.to_s
+            command = "propedit svn:externals #{external.container_dir}"
+            begin
+              response = confirm("Do you want to edit svn:externals for this directory?".black_on_white)
+              svn :system,  command if response == 'y'
+            rescue Interrupt
+              puts "\nGoodbye!"
+              throw :exit
+            ensure
+              puts
+            end
+          end
+          puts 'Done'
+        else
+          #system "#{Subversion.executable} propedit svn:externals #{directory}"
+          svn :system, "propedit svn:externals #{directory}"
+        end
+      end # catch :exit
+    end
+    alias_subcommand :edit_ext => :edit_externals
+    alias_subcommand :ee => :edit_externals
+    alias_subcommand :edit_external => :edit_externals
+
+    module Externalize
+      # :todo: shortcut to create both __whatever method that sets instance variable 
+      #   *and* accessor method 'whatever' for reading it (and ||= initializing it)
+#      Console::Command.option({
+#        :as => 1         # 1 is arity
+#        :as => [1, nil]  # 1 is arity, nil is default?
+#      )
+
+      def __as(as); @as = as; end
+      def as; @as; end
+    end
+    #   svn externalize http://your/repo/shared_tasks/tasks --as shared
+    # or
+    #   svn externalize http://your/repo/shared_tasks/tasks shared
+    def externalize(repo_path, as_arg = nil)
+      # :todo: let them pass in local_path as well? -- then we would need to accept 2 -- 3 -- args, the first one poylmorphic, the second optional
+      # :todo: automated test for as_arg/as combo
+
+      Subversion.externalize(repo_path, {:as => as || as_arg})
+    end
+
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+
+    def ignore(file)
+      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
+
+    module GetMessage
+      def _r(revision)
+        @revision = revision
+      end
+    end
+    def get_message()
+      #svn propget --revprop svn:log -r2325
+      args = ['propget', '--revprop', 'svn:log']
+      #args.concat ['-r', @revision ? @revision : Subversion.latest_revision]
+      args.concat ['-r', (revision = @revision ? @revision : 'head')]
+      puts "Message for r#{Subversion.latest_revision} :" if revision == 'head'
+
+      $ignore_dry_run_option = true
+      puts filtered_svn(*args)
+      $ignore_dry_run_option = false
+    end
+
+    module SetMessage
+      def _r(revision)
+        @revision = revision
+      end
+      def __file(filename)
+        @filename = filename
+      end
+    end
+    def set_message(new_message)
+      #svn propset --revprop -r 25 svn:log "Journaled about trip to New York."
+      puts "Message before changing:"
+      get_message
+
+      args = ['propset', '--revprop', 'svn:log']
+      args.concat ['-r', @revision ? @revision : 'head']
+      args << new_message if new_message
+      if @filename
+        contents = File.readlines(@filename).join.strip
+        puts "Read file '#{@filename}':"
+        print contents
+        puts
+        args << contents
+      end
+      svn :exec, *args
+    end
+
+    # Lets you edit it with your default editor
+    module EditRevisionProperty
+      def _r(revision)
+        @revision = revision
+      end
+    end
+    def edit_revision_property(property_name, directory = './')
+      args = ['propedit', '--revprop', property_name, directory]
+      rev = @revision ? @revision : 'head'
+      args.concat ['-r', rev]
+      Subversion.print_commands! do
+        svn :system, *args
+      end
+
+      value = Subversion::get_revision_property(property_name, rev)
+      p value
+
+      # Currently there is no seperate option to *delete* a revision property (propdel)... That would be useful for those
+      # properties that are just boolean *flags* (set or not set).
+      # I'm assuming most people will very rarely if ever actually want to set a property to the empty string (''), so
+      # we can use the empty string as a way to trigger a propdel...
+      if value == ''
+        puts
+        response = confirm("Are you sure you want to delete property #{property_name}".red.bold + "'? ")
+        puts
+        if response == 'y'
+          Subversion.print_commands! do
+            Subversion::delete_revision_property(property_name, rev)
+          end
+        end
+      end
+    end
+
+    # Lets you edit it with your default editor
+    module EditMessage
+      def _r(revision)
+        @revision = revision
+      end
+    end
+    def edit_message(directory = './')
+      edit_revision_property('svn:log', directory)
+    end
+
+    def edit_property(property_name, directory = './')
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Cause a working copy to cease being a working copy
+    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
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+
+    def add_all_unadded
+      raise NotImplementedError
+    end
+    def grep
+      raise NotImplementedError
+    end
+    def grep_externals
+      raise NotImplementedError
+    end
+    def grep_log
+      raise NotImplementedError
+    end
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    module Revisions
+      # Start at earlier revision and go forwards rather than starting at the latest revision
+      #def __reverse
+      def __forward
+        @reverse = true
+      end
+      def __forwards
+        @reverse = true
+      end
+
+      # Only show revisions that are in need of a code review
+      # :todo:
+      def __unreviewed_only
+        @unreviewed_only = true
+      end
+
+      # Only show revisions that were committed by a certain author.
+      # :todo:
+      def __by(author)
+        @author_filter = author
+      end
+      def __author(author)
+        @author_filter = author
+      end
+    end
+    def revisions(directory = './')
+      puts "Getting list of revisions for '#{directory.white.bold}' ..."
+
+      head = Subversion.latest_revision
+      revision_of_directory = Subversion.latest_revision_for_path(directory)
+
+      # It's possible for a working copy to get "out of date" (even if you were the last committer!), in which case svn log will
+      # only list revisions up to that revision (actually looks like it only goes up to and including Last Changed Rev: 2838,
+      # not Revision: 2839, as reported by svn info...)
+      if revision_of_directory and head and revision_of_directory < head
+        puts "The working copy '#{directory.white.bold}' appears to be out-of-date (#{revision_of_directory}) with respect to the head revision (#{head}). Updating..."
+        Subversion.update(directory)
+      end
+
+      revisions = Subversion.revisions(directory)
+
+      puts "#{revisions.length.to_s.bold} revisions found. Starting with #{@reverse ? 'oldest' : 'most recent'} revision and #{@reverse ? 'going forward in time' : 'going backward in time'}..."
+      revisions.instance_variable_get(:@revisions).reverse! if @reverse
+      revision_ids = revisions.map(&:identifier)
+
+      target_rev = nil # revision_ids.first
+      show_revision_again = true
+      revisions.each do |revision|
+        rev = revision.identifier
+        other_rev = rev-1
+        if target_rev
+          if rev == target_rev
+            target_rev = nil    # We have arrived.
+          else
+            next                # Keep going (hopefully in the right direction!)
+          end
+        end
+
+        # Display the revision
+        if show_revision_again
+          puts((' '*100).green.underline)
+          puts "#{revisions.length - revision_ids.index(rev)}. ".green.bold +
+            "r#{rev}".magenta.bold + (rev == head ? ' (head)'.bold : '') + 
+            " | #{revision.developer} | #{revision.time.strftime('%Y-%m-%d %H:%M:%S')}".magenta.bold
+          puts revision.message
+          puts
+          #pp revision
+          puts revision.map {|a|
+            (a.status ? a.status[0..0].colorize_svn_status_code : ' ') +   # This check is necessary because RSCM doesn't recognize several Subversion status flags, including 'R', and status will return nil in these cases.
+              ' ' + a.path
+          }.join("\n")
+        else
+          show_revision_again = true
+        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'.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') + ', ' +
+          'or ' + 'browse using ' + 'Up/Down/Enter'.white.bold + ' keys > '
+        )
+
+        # Get response from user and then act on it
+        begin # rescue
+          response = ""
+          response = $stdin.getch.downcase
+
+          # Escape sequence such as the up arrow key ("\e[A")
+          if response == "\e"
+            response << (next_char = $stdin.getch)
+            if next_char == '['
+              response << (next_char = $stdin.getch)
+            end
+          end
+
+          if response == 'd' # diff against Other revision
+            response = 'v'
+            puts
+            print 'All right, which revision shall it be then? '.bold + ' (backspace not currently supported)? '
+            other_rev = $stdin.gets.chomp.to_i
+          end
+
+          case response
+            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
+              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 + ' (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 #{directory} -r #{revs_to_compare.min}:#{revs_to_compare.max}` for #{search_pattern.to_s}... ".bold
+              diffs = nil
+              Subversion.print_commands! do
+                diffs = Subversion.diffs(directory, '-r', "#{revs_to_compare.min}:#{revs_to_compare.max}")
+              end
+
+              hits = 0
+              diffs.each do |filename, diff|
+                #.grep(search_pattern)
+                if diff.diff =~ search_pattern
+                  puts diff.filename_pretty
+                  puts( diff.diff.grep(search_pattern). # This will get us just the interesting *lines* (as an array). 
+                    map { |line|                        # Now, for each line...
+                      hits += 1
+                      line.highlight_occurences(search_pattern)
+                    }
+                  )
+                end
+              end
+              if hits == 0
+                puts "Search term not found!".red.bold
+              end
+              show_revision_again = false
+
+            when 'a'  # Grep the cat
+              puts
+              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 cat #{directory} -r #{rev}` for #{search_pattern.to_s}... ".bold
+              contents = nil
+              Subversion.print_commands! do
+                contents = Subversion.cat(directory, '-r', rev)
+              end
+
+              if contents =~ search_pattern
+                puts( contents.grep(search_pattern). # This will get us just the interesting *lines* (as an array). 
+                  map { |line|                       # Now, for each line...
+                    line.highlight_occurences(search_pattern)
+                  }
+                )
+              else
+                puts "Search term not found!".red.bold
+              end
+              show_revision_again = false
+
+
+            when 'l'  # List revision properties
+              puts
+              puts Subversion::printable_revision_properties(rev)
+              show_revision_again = false
+
+            when 'e'  # Edit revision property
+              puts
+              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! do
+                  @revision = rev
+                  edit_revision_property(property_name, directory)
+                end
+              end
+
+              show_revision_again = false
+
+            when 'c'  # Cat all files from revision
+              puts
+              Subversion.print_commands! do
+                puts Subversion.cat(directory, '-r', rev)
+              end
+              show_revision_again = true
+
+            when 'r'  # Mark as reviewed
+              puts
+              your_name = ENV['USER'] # I would use the same username that Subversion itself would use if you committed
+                                      # something (since it is sometimes different from your system username), but I don't know
+                                      # 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! 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! do
+                SvnCommand.execute("edit_message -r #{rev}")
+              end
+              show_revision_again = false
+
+            when "\e[A" # Up
+              i = revision_ids.index(rev)
+              target_rev = revision_ids[i - 1]
+              puts " Previous..."
+              retry
+
+              
+            when /\n|\e\[B/ # Enter or Down
+              # Skip / Do nothing with this file
+              puts " Next..."
+              next
+
+            else
+              # Invalid option. Do nothing.
+              #puts response.inspect
+              puts
+              show_revision_again = false
+
+          end # case response
+
+          redo # Until they tell us they're ready to move on...
+
+        rescue Interrupt
+          puts "\nGoodbye!"
+          return
+        end # rescue
+      end
+    end
+    alias_subcommand :changesets        => :revisions
+    alias_subcommand :browse            => :revisions
+    alias_subcommand :browse_log        => :revisions
+    alias_subcommand :browse_revisions  => :revisions
+    alias_subcommand :browse_changesets => :revisions
+    # See also the implementation of revisions() in /usr/lib/ruby/gems/1.8/gems/rscm-0.5.1/lib/rscm/scm/subversion.rb
+    # Other name ideas: browse, list_commits, changeset_browser, log_browser, interactive_log
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Aliases
+    #:stopdoc:
+    alias_subcommand :st => :status
+    alias_subcommand :up => :update
+    alias_subcommand :ci => :commit
+    #:startdoc:
+
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    # Helpers
+
+  private
+    def svn(method, *args)
+      subcommand = args[0]
+      options = args.last.is_a?(Hash) ? args.last : {}
+      args = (
+        [subcommand] + 
+        (
+          (options[:prepare_args] == false) ? 
+            [] : 
+            (prepare_args(args[1..-1] || []))
+        ) + 
+        [:method => method]
+      )
+      # puts "in svn(): about to call Subversion#execute(#{args.inspect})"
+      Subversion.send :execute, *args
+    end
+
+    # Works identically to svn() except that it filters the output and displays a big red error message if /usr/bin/svn exied with an error.
+    def filtered_svn(*args)
+      # We have to use the :capture method if we're going to filter the output.
+      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
+      @passthrough_options + args.shell_escape
+    end
+    # To allow testing/stubbing
+    def system(*args)
+      Kernel.system *args
+    end
+  end
+end