svn-command 0.1.1 → 0.2.1

data/Readme

@@ -5,10 +5,12 @@
 [<b>Project site</b>:]     http://rubyforge.org/projects/svn-command
 [<b>Wiki</b>:]             http://wiki.qualitysmith.com/svn-command
 [<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]
 
 == Introduction
 
-This is a replacement <tt>svn</tt> <b>command-line client</b> meant to be used instead of the standard +svn+ command. Actually, it's a /wrapper/, not a replacement, because it still uses <tt>/usr/bin/svn</tt> to do all the dirty work.
+This is a replacement <tt>svn</tt> <b>command-line client</b> meant to be used instead of the standard +svn+ command. Actually, it's a _wrapper_, not a replacement, because it still uses <tt>/usr/bin/svn</tt> to do all the dirty work.
 
 == Installation
 
@@ -44,29 +46,33 @@ You'll know it's working by way of two signs:
 == Features
 
 Changes to existing subcommands:
-* <tt>svn diff</tt> output is in _color_* (requires +colordiff+, see below)
-* <tt>svn diff</tt> includes the differences from your *externals* too (consistent with how <tt>svn status</tt> includes them) so that you don't forget to commit those changes too!
+* <tt>svn diff</tt>
+  * output is in _color_* (requires +colordiff+, see below)
+  * <tt>svn diff</tt> includes the differences from your *externals* too (consistent with how <tt>svn status</tt> includes them) so that you don't forget to commit those changes too! (pass <tt>--ignore-externals</tt> if you _don't_ want a diff of externals)
 * <tt>svn status</tt>
-** filters out distracting, useless output about externals (don't worry -- it still shows which files were _modified_)
-** the flags (?, M, C, etc.) are in *color*!
-* <tt>svn move</tt> -- it will let you move multiple source files to a destination directory with a single command
+  * filters out distracting, useless output about externals (don't worry -- it still shows which files were _modified_)
+  * the flags (?, M, C, etc.) are in *color*!
+* <tt>svn move</tt> it will let you move multiple source files to a destination directory with a single command
 
 (* You can pass --no-color to disable colors for a single command...useful if you want to pipe the output to another command or something. Eventually maybe we could make this a per-user option via .svn-command?)
 
 New subcommands:
 * <tt>svn each_unadded</tt> (+eu+, +unadded+) -- goes through each unadded (<tt>?</tt>) file reported by <tt>svn status</tt> and asks you what to do with them (add, delete, ignore).
 * <tt>svn externals</tt> -- lists all externals
+* <tt>svn revisions</tt> -- lists all revisions with log messages and lets you browse through them interactively
 * <tt>svn edit_externals</tt> (+ee+)
 * <tt>svn externalize</tt>
 * <tt>svn set_message</tt> / <tt>svn get_message</tt> / <tt>svn edit_message</tt> -- shortcuts for accessing <tt>--revprop svn:log</tt>
 * <tt>svn ignore</tt> -- shortcut for accessing <tt>svn:ignore</tt> property
 * <tt>svn view_commits</tt> -- gives you output from both <tt>svn log</tt> and from <tt>svn diff</tt> for the given changesets (useful for code reviews)
+* <tt>svn repository_root</tt> -- prints out the root repository URL of the working copy you are in
+* <tt>svn delete_svn</tt> -- causes the current directory (recursively) to no longer be a working copy
 
 (RDoc question: how do I make the identifiers like Subversion::SvnCommand#externalize into links??)
 
-== Usage
+= Usage / Examples
 
-=== <tt>st</tt>
+== <tt>svn st</tt>
 
 _Without_ this gem installed (really long):
 
@@ -106,7 +112,7 @@ _Without_ this gem installed (really long):
   A      gemables/subversion/bin/svn
   M      applications/underlord/vendor/plugins/rails_smith/tasks/shared/base.rake
 
-=== <tt>each_unadded</tt>
+== <tt>svn each_unadded</tt>
 
 My personal favorite. This command is useful for keeping your working copies clean -- getting rid of all those accumulated temp files (or *ignoring* or *adding* them if they're something that _all_ users of this repository should be aware of).
 
@@ -130,9 +136,9 @@ It simply goes through each "unadded" file (each file reporting a status of <tt>
   Are you pretty much *SURE* you want to 'rm -rf applications/underlord/vendor/plugins/exception_notification'? (y)es, (n)o > y
   Deleting...
 
-For *files*, it will show a preview of the _contents_ of that file (limited to the first 3000 characters); for *directories*, it will show a _directory_ _listing_. By looking at the preview, you should hopefully be able to decide whether you want to _keep_ the file or _junk_ it.
+For *files*, it will show a preview of the _contents_ of that file (limited to the first 55 lines); for *directories*, it will show a _directory_ _listing_. By looking at the preview, you should hopefully be able to decide whether you want to _keep_ the file or _junk_ it.
 
-===<tt>externalize</tt> / <tt>externals</tt> / <tt>edit_externals</tt>
+==<tt>svn externalize</tt> / <tt>externals</tt> / <tt>edit_externals</tt>
 
 Shortcut for creating an svn:external...
 
@@ -168,7 +174,7 @@ You can also pass a directory name to edit_externals to edit the svn:externals p
 
   > svn edit-externals vendor/plugins
 
-===<tt>get_message</tt> / <tt>set_message</tt> / <tt>edit_message</tt>
+==<tt>svn get_message</tt> / <tt>set_message</tt> / <tt>edit_message</tt>
 
 <b>Pre-requisite for set_message/edit_message</b>: Your repository must have a <tt>pre-revprop-change</tt> hook file.
 
@@ -187,18 +193,29 @@ You can do this:
 or just this:
   svn edit_message
 
-=== <tt>move</tt>
+== <tt>svn move</tt>
 
 You can now do commands like this:
 
   svn mv file1 file2 dir
   svn mv dir1/* dir
 
-(The standard svn command only accepts a single source and a single destination.)
+(The _standard_ +svn+ command only accepts a _single_ source and a _single_ destination!)
 
-=== <tt>commit</tt>
+== <tt>svn revisions</tt> (revisions browser)
 
-==== --skip-notification / --covert
+Lets you interactively step through all revisions of a file/directory/repository.
+
+
+Note: You may have to svn update your working copy in order for svn log (and hence svn revisions) to be able to see the revisions you just committed.
+
+
+Use the <tt>--forwards</tt> flag if you want to <u>start at the oldest revision</u> and step forwards through time rather than starting at the latest revision and stepping backwards (the default).
+
+
+== <tt>svn commit</tt>
+
+=== --skip-notification / --covert
 
 Added a --skip-notification / --covert option which (assuming you have your post-commit hook set up to do this), will suppress the sending out of a commit notification e-mail.
 
@@ -249,11 +266,11 @@ For this option to have any effect, you will need to set up your repository simi
 
 
 
-===Help
+==Help
 
 You can, of course, get a lits of the custom commands that have been added by using <tt>svn help</tt>. They will be listed at the end.
 
-===Global options
+==Global options
 
 * --no-color (since color is on by default)
 * --dry-run  (see what /usr/bin/svn command it _would_ have executed if you weren't just doing a dry run -- useful for debugging if nothing else)
@@ -283,6 +300,14 @@ If you want command completion for the svn subcommands (and I don't blame you if
 
 It's really rudimentary right now and could be much improved, but at least it's a start.
 
+==Support for code reviews, commit notification, and continuous integration systems
+
+The <tt>svn revisions</tt> command lets you browse through recent changes to a project or directory and then, for each revision that you review, you can simply press R and it will mark that revision as reviewed.
+
+<tt>svn commit</tt> accepts two custom flags, <tt>--skip-notification / --covert</tt> (don't send commit notification) and <tt>--broken</tt> (tell the continuous integration system to expect failure).
+
+=Other
+
 ==Known problems
 
 It doesn't support options that are given in this format:

data/lib/svn-command/subversion.rb

@@ -21,6 +21,12 @@ gem 'qualitysmith_extensions', '>=0.0.7'
 gem 'qualitysmith_extensions'
 require 'qualitysmith_extensions/module/attribute_accessors'
 
+# RSCM is used for some of the abstraction, such as for parsing log messages into nice data structures. It seems like overkill, though, to use RSCM for most things...
+gem 'rscm'
+#require 'rscm'
+#require 'rscm/scm/subversion'
+require 'rscm/scm/subversion_log_parser'
+
 # Wraps the Subversion shell commands for Ruby.
 module Subversion
   # True if you want output from svn to be colorized (useful if output is for human eyes, but not useful if using the output programatically)
@@ -137,6 +143,9 @@ module Subversion
     execute("update #{args.join ' '}")
   end
 
+  # The output from `svn status` is nicely divided into two "sections": the section which pertains to the current working copy (not
+  # counting externals as part of the working copy) and then the section with status of all of the externals.
+  # This method returns the first section.
   def self.status_the_section_before_externals(path = './')
     status = status(path) || ''
     status.sub!(/(Performing status.*)/m, '')
@@ -197,15 +206,47 @@ module Subversion
     self.set_property property, lines.join("\n"), path
   end
 
+  # :todo: Stop assuming the svn: namespace. What's the point of a namespace if you only allow one of them?
   def self.get_property(property, path = './')
     execute "propget svn:#{property} #{path}"
   end
+  def self.get_revision_property(property_name, rev)
+    execute("propget --revprop #{property_name} -r #{rev}").chomp
+  end
+
   def self.delete_property(property, path = './')
     execute "propdel svn:#{property} #{path}"
   end
+  def self.delete_revision_property(property_name, rev)
+    execute("propdel --revprop #{property_name} -r #{rev}").chomp
+  end
+
   def self.set_property(property, value, path = './')
     execute "propset svn:#{property} '#{value}' #{path}"
   end
+  def self.set_revision_property(property_name, rev)
+    execute("propset --revprop #{property_name} -r #{rev}").chomp
+  end
+
+  # Gets raw output of proplist command
+  def self.proplist(rev)
+    execute("proplist --revprop -r #{rev}")
+  end
+  # Returns an array of the names of all revision properties currently set on the given +rev+
+  # Tested by: ../../test/subversion_test.rb:test_revision_properties_names
+  def self.revision_properties_names(rev)
+    raw_list = proplist(rev)
+    raw_list.scan(/^ +([^ ]+)$/).map { |matches|
+      matches.first.chomp
+    }
+  end
+  # Returns an array of RevisionProperty objects (name, value) for revisions currently set on the given +rev+
+  # Tested by: ../../test/subversion_test.rb:test_revision_properties
+  def self.revision_properties(rev)
+    revision_properties_names(rev).map { |property_name|
+      RevisionProperty.new(property_name, get_revision_property(property_name, rev))
+    }
+  end
 
   def self.make_directory(dir)
     execute "mkdir #{dir}"
@@ -215,16 +256,32 @@ module Subversion
     execute "help #{args.join(' ')}"
   end
 
+  # Returns the raw output from svn log
   def self.log(*args)
     args = ['./'] if args.empty?
     execute "log #{args.join(' ')}"
   end
+  # Returns the revision number for head.
   def self.latest_revision(*args)
     args = ['./'] if args.empty?
     matches = /Status against revision:\s+(\d+)/m.match(status_against_server(args))
     matches && matches[1]
   end
 
+  # Returns an array of RSCM::Revision objects
+  def self.revisions(*args)
+    # Tried using this, but it seems to expect you to pass in a starting date or accept the default starting date of right now, which is silly if you actually just want *all* revisions...
+    #@rscm = ::RSCM::Subversion.new
+    #@rscm.revisions
+
+    #log_output = Subversion.log('-v')
+    log_output = Subversion.log(*(['-v'] + args))
+    parser = ::RSCM::SubversionLogParser.new(io = StringIO.new(log_output), url = 'http://ignore.me.com')
+    revisions = parser.parse_revisions
+    revisions
+  end
+
+
   def self.info(*args)
     args = ['./'] if args.empty?
     execute "info #{args.join(' ')}"
@@ -232,26 +289,32 @@ module Subversion
 
   # :todo: needs some serious unit-testing love
   def self.base_url(path_or_url = './')
-    base_url = nil    # needed so that base_url variable isn't local to if block!
-    started_using_dot_dots = false
-    loop do
-      matches = /URL: (.+)/.match(info(path_or_url))
-      if matches && matches[1]
-        base_url = matches[1]
-      else
-        break base_url
-      end
-
-      # Keep going up the path, one directory at a time, until `svn info` no longer returns a URL (will probably eventually return 'svn: PROPFIND request failed')
-      if path_or_url.include?('/') && !started_using_dot_dots
-        path_or_url = File.dirname(path_or_url)
-      else
-        started_using_dot_dots = true
-        path_or_url = File.join(path_or_url, '..')
-      end
-      #puts 'going up to ' + path_or_url
-    end
-  end
+     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 
+#    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
+#      matches = /^URL: (.+)/.match(info(path_or_url))
+#      if matches && matches[1]
+#        base_url = matches[1]
+#      else
+#        break base_url
+#      end
+#
+#      # Keep going up the path, one directory at a time, until `svn info` no longer returns a URL (will probably eventually return 'svn: PROPFIND request failed')
+#      if path_or_url.include?('/') && !started_using_dot_dots
+#        path_or_url = File.dirname(path_or_url)
+#      else
+#        started_using_dot_dots = true
+#        path_or_url = File.join(path_or_url, '..')
+#      end
+#      #puts 'going up to ' + path_or_url
+#    end
+  end
+  def self.root_url(*args);        base_url(*args); end
+  def self.repository_root(*args); base_url(*args); end
 
   # The location of the executable to be used
   def self.executable
@@ -294,11 +357,17 @@ protected
 
     valid_options = [:capture, :exec, :popen]
     case method
+
       when :capture
         `#{command} 2>&1` 
+
       when :exec
         #Kernel.exec *args
         Kernel.exec command
+
+      when :system
+        Kernel.system command
+
       when :popen
         # This is just an idea of how maybe we could improve the LATENCY. Rather than waiting until the command completes
         # (which can take quite a while for svn status sometimes since it has to walk the entire directory tree), why not process
@@ -338,8 +407,12 @@ end
 
 
 
+#Subversion.const_set(:RevisionProperty) = Struct.new(:name, :repository_path)
 
 module Subversion
+
+  RevisionProperty = Struct.new(:name, :value)
+
   # Represents an "externals container", which is a directory that has the <tt>svn:externals</tt> property set to something useful.
   # Each ExternalsContainer contains a set of "entries", which are the actual directories listed in the <tt>svn:externals</tt>
   # property and are "pulled into" the directory.

data/lib/svn-command/subversion_extensions.rb

@@ -1,4 +1,4 @@
-# Tested by: ../test/subversion_extensions_test.rb
+# Tested by: ../../test/subversion_extensions_test.rb
 
 gem 'colored'
 require 'colored'
@@ -10,26 +10,42 @@ class Array
 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(/^ *\?/) { $&.yellow.bold}.
-           gsub(/^ *A/)  { $&.green.bold}.
-           gsub(/^ *M/)  { $&.green.bold}.
-           gsub(/^ *D/)  { $&.magenta.bold}.
-           gsub(/^ *C/)  { $&.red.bold}.
-           gsub(/^ *~/)  { $&.red.bold}.
-           gsub(/^ *!/)  { $&.red.bold}
+      self.gsub(/^ *([^ ])\s/) { $&.colorize_svn_status_code }
     else
       self
     end
   end
   def colorize_svn_update_lines
     if Subversion.color
-      self.gsub(/^ *U\s/)  { $&.yellow.bold}.
-           gsub(/^ *A\s/)  { $&.green.bold}.
-           gsub(/^ *M\s/)  { $&.green.bold}.
-           gsub(/^ *D\s/)  { $&.magenta.bold}.
-           gsub(/^ *C\s/)  { $&.red.bold}
+      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
@@ -110,9 +126,16 @@ module Subversion
       }
     end
 
-    # This is just a wrapper for Subversion.diff that adds some color
+    # This is just a wrapper for Subversion::diff that adds some color
     def self.diff(*args)
-      output = Subversion.diff(*args).colorize_svn_diff.add_exit_code_error
+      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

data/lib/svn-command/svn_command.rb

@@ -7,6 +7,7 @@ require 'facets/core/kernel/require_local'
 require 'facets/core/array/select'      # select!
 require 'facets/core/kernel/with'       # returning
 require 'facets/core/string/lines'
+require 'facets/core/string/index_all'
 
 gem 'qualitysmith_extensions', '>=0.0.3'
 require 'qualitysmith_extensions/enumerable/enum'
@@ -22,6 +23,8 @@ require 'termios'
 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'
 
@@ -42,8 +45,14 @@ end
 
 class String
   # Makes the first character bold and underlined. Makes the whole string of the given color.
-  def menu_item(color = :white)
-    self[0..0].send(color).bold.underline + self[1..-1].send(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
   def add_exit_code_error
     self << "Exited with error!".bold.red if !$?.success?
@@ -74,8 +83,12 @@ module Subversion
       'each_unadded',
       'externals_items', 'externals_outline', 'externals_containers', 'edit_externals', 'externalize',
       'ignore',
+      'revisions',
       'get_message', 'set_message', 'edit_message',
-      'view_commits'
+      'view_commits',
+      'repository_root',
+      'latest_revision',
+      'delete_svn'
     ]
     mattr_reader :subcommand_list
 
@@ -87,7 +100,7 @@ module Subversion
     #-----------------------------------------------------------------------------------------------------------------------------
     # Global options
     
-    global_option :__no_color, :__dry_run, :__debug
+    global_option :__no_color, :__dry_run, :__debug, :__print_commands
     def __no_color
       Subversion::color = false
     end
@@ -101,10 +114,20 @@ module Subversion
     def __print_commands
       Subversion::print_commands = true
     end
-    # Don't want to hide svn's own -v/--verbose flag
-    alias_method :__Verbose,        :__print_commands
     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
@@ -188,20 +211,44 @@ module Subversion
           [:__encoding] => 1,
         }.merge(SvnCommand::standard_remote_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
+
+      # 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
     end
     def commit(*args)
       Subversion.print_commands_for do
-        svn :capture, "propset svn:skip_commit_notification_for_next_commit true --revprop -r #{Subversion.latest_revision}", :prepare_args => false
+        puts svn(:capture, "propset svn:skip_commit_notification_for_next_commit true --revprop -r #{Subversion.latest_revision}", :prepare_args => false)
       end if @skip_notification
-      svn :exec, 'commit', *(['--force-log'] + args)
-
       # :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)?)
+
+      puts output = svn(:capture, 'commit', *(['--force-log'] + args))
+
+      just_committed = (matches = output.match(/Committed revision (\d+)\./)) && matches[1]
+
+      Subversion.print_commands_for do
+        puts svn(:capture, "propset code:broken true --revprop -r #{just_committed}", :prepare_args => false)
+      end if @broken
+
     end
 
     # Ideas:
@@ -222,17 +269,20 @@ module Subversion
           [:__force] => 1,
         }.merge(SvnCommand::standard_remote_command_options), self
       )
+      def __ignore_externals
+        @ignore_externals = true
+      end
     end
 
     def diff(*directories)
-      directories = ["./"] if directories.empty?
+      directories = ['./'] if directories.empty?
       puts Extensions.diff(*(directories + @passthrough_options))
 
-      # Show diff for externals (if there are any)
-      output = StringIO.new
-      #paths = args.reject{|arg| arg =~ /^-/} || ['./']
-      directories.each do |path|
-        (Subversion.externals_items(path) || []).each do |item|
+      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
             unless diff_output == ""
               #output.puts '-'*100
@@ -240,14 +290,15 @@ module Subversion
               output.puts item.black_on_white.bold
               output.puts diff_output
             end
+          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
+        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
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
@@ -268,9 +319,11 @@ module Subversion
           # :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 + ", a colorful, useful replacement/wrapper for the standard svn command."
+          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 "svn-command is installed at: " + $0.bold
-          puts "Use the full path to bypass this wrapper: " + Subversion.executable.bold
+          puts "You may bypass this wrapper by using the full path to svn: " + Subversion.executable.bold
           puts
           puts Subversion.help(subcommand).gsub(<<End, '')
 
@@ -278,7 +331,8 @@ Subversion is a tool for version control.
 For additional information, see http://subversion.tigris.org/
 End
 
-          puts '   ' + '--------------'
+          puts
+          puts 'Subcommands added by svn-command (refer to '.green.underline + 'http://svn-command.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(', ') + ')'
@@ -395,6 +449,20 @@ End
     # Custom subcommands
     #-----------------------------------------------------------------------------------------------------------------------------
 
+    #-----------------------------------------------------------------------------------------------------------------------------
+    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*
@@ -460,8 +528,6 @@ End
         Subversion::Extensions.each_unadded( Subversion.status(*args) ) do |file|
           $ignore_dry_run_option = false
           begin
-            response = ""
-
             puts( ('-'*100).green )
             puts "What do you want to do with '#{file.white.underline}'?".white.bold
             begin
@@ -495,7 +561,7 @@ End
               "or " + "any other key".white.bold + " to do nothing > "
             )
             response = ""
-            response = $stdin.getc.chr # while !['a', 'd', 'i', "\n"].include?(begin response.downcase!; response end)
+            response = $stdin.getc.chr.downcase # while !['a', 'd', 'i', "\n"].include?(begin response.downcase!; response end)
 
 
             case response
@@ -512,7 +578,7 @@ End
                     "Yes".menu_item(:red) + ", " +
                     "No".menu_item(:green) + 
                     " > "
-                  response = $stdin.getc.chr while !['y', 'n', "\n"].include?(begin response.downcase!; response end)
+                  response = $stdin.getc.chr.downcase while !['y', 'n', "\n"].include?(begin response.downcase!; response end)
                 else
                   response = "y"
                 end
@@ -530,10 +596,10 @@ End
                 puts
               else
                 # Skip / Do nothing with this file
-                puts
+                puts " (Skipping...)"
             end
           rescue Interrupt
-            puts "Goodbye"
+            puts "\nGoodbye!"
             throw :exit
           end
         end # each_unadded
@@ -633,10 +699,10 @@ End
             begin
               #print "Press Ctrl-C to skip, any other key to continue. (This will start up your default editor.) "
               print "Do you want to edit svn:externals for this directory?".black_on_white + ' ' + 'yes'.menu_item(:white) + '/' + 'No'.menu_item(:white) + " > "
-              response = $stdin.getc.chr
-              system command if response.downcase == 'y'
+              response = $stdin.getc.chr.downcase
+              system command if response == 'y'
             rescue Interrupt
-              puts "Goodbye"
+              puts "\nGoodbye!"
               throw :exit
             ensure
               puts
@@ -727,17 +793,62 @@ 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_for 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
+        print "Are you sure you want to delete property #{property_name}".red.bold + "'? " +
+          "Yes".menu_item(:red) + ", " +
+          "No".menu_item(:green) + 
+          " > "
+        response = ''
+        response = $stdin.getc.chr.downcase while !['y', 'n', "\n"].include?(begin response.downcase!; response end)
+        puts
+        if response == 'y'
+          Subversion.print_commands_for 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()
-      #svn propedit --revprop -r 25 svn:log
-      args = ['propedit', '--revprop', 'svn:log']
-      args.concat ['-r', @revision ? @revision : 'head']
-      svn :exec, *args
+    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
+      system('find -name .svn | xargs -n1 echo')
+      system('find -name .svn | xargs -n1 rm -r')
     end
 
     #-----------------------------------------------------------------------------------------------------------------------------
@@ -754,9 +865,191 @@ End
     def grep_log
       raise NotImplementedError
     end
-    def browse
-      raise NotImplementedError
+
+    #-----------------------------------------------------------------------------------------------------------------------------
+    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
+      end
+    end
+    # :todo: document in readme! test! release! annouce!
+    def revisions(directory = './')
+      puts "Getting list of revisions for '#{directory.white.bold}' ..."
+
+      head = Subversion.latest_revision
+      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(
+          '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') + ', ' +
+          '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.getc.chr.downcase
+
+          # Escape sequence such as the up arrow key ("\e[A")
+          if response == "\e"
+            response << (next_char = $stdin.getc.chr)
+            if next_char == '['
+              response << (next_char = $stdin.getc.chr)
+            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'  # Diff
+              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}")
+
+            when 'g'  # Grep the changeset
+              revs_to_compare = [other_rev, rev]
+              puts
+              puts((' '*100).green.underline)
+              print "Diffing #{revs_to_compare.min}:#{revs_to_compare.max}... ".bold
+              puts
+              puts Extensions.diff(directory, '-r', "#{revs_to_compare.min}:#{revs_to_compare.max}")
+
+            when 'l'  # List revision properties
+              puts
+              puts Subversion::Extensions::printable_revision_properties(rev)
+              show_revision_again = false
+
+            when 'e'  # Edit revision property
+              puts
+              puts Subversion::Extensions::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
+                  @revision = rev
+                  edit_revision_property(property_name, directory)
+                end
+              end
+
+              show_revision_again = false
+
+            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_for 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
+
+            when 'm'  # Edit log message
+              puts
+              Subversion.print_commands_for do
+                SvnCommand.execute("edit_message -r #{rev}")
+              end
+
+            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
@@ -794,7 +1087,8 @@ End
     end
 
     def prepare_args(args)
-      args.compact!   # nil elements spell trouble
+      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

data/test/subversion_test.rb

@@ -96,4 +96,48 @@ class SubversionTest < Test::Unit::TestCase
     assert_equal "svn status foo", Subversion.executed.first
   end
 
+  def test_revisions
+    Subversion.stubs(:log).returns(<<End)
+------------------------------------------------------------------------
+r407119 | moo | 2006-05-16 20:27:28 -0500 (Tue, 16 May 2006) | 5 lines
+Changed paths:
+   M /trunk/cow/black.rb
+   M /trunk/cow/brown.rb
+
+Commit message...
+------------------------------------------------------------------------
+End
+    assert_equal 1, Subversion.revisions.length
+    assert_equal RSCM::Revision, Subversion.revisions[0].class
+    assert_equal RSCM::RevisionFile, Subversion.revisions[0][0].class
+    assert_equal 'modified', Subversion.revisions[0][0].status.downcase
+    assert_equal 'trunk/cow/black.rb', Subversion.revisions[0][0].path
+    assert_equal 'trunk/cow/brown.rb', Subversion.revisions[0][1].path
+    assert_equal 'Commit message...', Subversion.revisions[0].message
+  end
+
+  def test_revision_properties_names
+    Subversion.stubs(:proplist).returns(<<End)
+Unversioned properties on revision 2819:
+  svn:log
+  svn:author
+  svn:date
+End
+    assert_equal ['svn:log', 'svn:author', 'svn:date'], Subversion.revision_properties_names(rev = 14)
+  end
+  def test_revision_properties
+    Subversion.stubs(:proplist).returns(<<End)
+Unversioned properties on revision 2819:
+  svn:log
+  svn:author
+  svn:date
+End
+    Subversion.stubs(:get_revision_property).returns('a value')
+
+    assert_equal [
+      Subversion::RevisionProperty.new('svn:log', 'a value'),
+      Subversion::RevisionProperty.new('svn:author', 'a value'),
+      Subversion::RevisionProperty.new('svn:date', 'a value'),
+    ], Subversion.revision_properties(rev = 14)
+  end
 end

data/test/svn_command_test.rb

@@ -4,12 +4,62 @@ require_local '../lib/svn-command/svn_command.rb'
 require 'facets/core/string/to_re'
 require 'yaml'
 
+
+require 'facets/core/module/alias_method_chain'
+require 'qualitysmith_extensions/string/each_char_with_index'
+module Test
+  module Unit
+    module Assertions
+      # Rather than showing the expected and the actual and asking the user to figure out the commonalities and differences
+      # himself, this method will highlight the differences for the user (in color), so that they can be spotted in less than
+      # an instant!
+      # Strings: show common characters in a plain color and highlight the characters that differ (at that index) in yellow.
+      # Strings: show common elements in a plain color and highlight the elements that differ (at that index) in yellow.
+      def assert_equal_with_difference_highlighting(expected, actual, message=nil)
+        String.class_eval do
+          alias_method :colorize, :colorize_without_no_color
+        end
+        if String===expected && String===actual
+          expected_with_highlighting = ''
+          actual_with_highlighting = ''
+          expected.each_char_with_index do |i, c|
+            if c != actual[i].chr
+              expected_with_highlighting << c.yellow
+              actual_with_highlighting   << actual[i].chr.yellow
+            else
+              expected_with_highlighting << c
+              actual_with_highlighting   << c
+            end
+
+          end
+          full_message = build_message(message, <<End, expected_with_highlighting, actual_with_highlighting)
+<?>
+expected but was
+<?>.
+End
+          puts actual_with_highlighting if expected != actual
+          assert_block(full_message) { expected == actual }
+        else
+          assert_equal_without_difference_highlighting(expected, actual, message)
+        end
+        String.class_eval do
+          alias_method :colorize, :colorize_with_no_color
+        end
+      end # def assert_equal_with_difference_highlighting
+
+      alias_method_chain :assert_equal, :difference_highlighting
+    end
+  end
+end
+
+
 Subversion.color = false
 # Makes testing simpler. We can test all the *colorization* features via *manual* testing (since they're not as critical).
 class String
-  def colorize(string, options = {})
+  def colorize_with_no_color(string, options = {})
     string
   end
+  alias_method_chain :colorize, :no_color
 end
 
 module Subversion
@@ -443,10 +493,28 @@ end
 class SvnEditMessageTest < BaseSvnCommandTest
   def test_1
     Subversion.stubs(:status_against_server).returns("Status against revision:     56")
+    Subversion.stubs(:get_revision_property).returns("The value I just set it to using vim, my favorite editor")
     output = simulate_input('i') do
       capture_output { SvnCommand.execute('edit_message') }
     end
-    assert_equal ["svn propedit --revprop svn:log -r head"], Subversion.executed
+    assert_equal ["svn propedit --revprop svn:log ./ -r head"], Subversion.executed
+  end
+end
+
+class SvnEditMessageTest < BaseSvnCommandTest
+  def test_can_actually_delete_property_too
+    Subversion.stubs(:status_against_server).returns("Status against revision:     56")
+    Subversion.stubs(:get_revision_property).returns("")
+    output = simulate_input(
+      'y'      # Yes I'm sure I want to delete the svn:fooo property for this revision.
+    ) do
+      capture_output { SvnCommand.execute('edit_revision_property svn:foo') }
+    end
+    assert_match /Are you sure you want to delete/, output
+    assert_equal [
+      "svn propedit --revprop svn:foo ./ -r head",
+      "svn propdel --revprop svn:foo -r head"
+    ], Subversion.executed
   end
 end
 
@@ -493,6 +561,104 @@ class SvnViewCommitsTest < BaseSvnCommandTest
   end
 end
 
+#-----------------------------------------------------------------------------------------------------------------------------
+# Changeset/commit/log Browser
+
+class SvnRevisionsTest < BaseSvnCommandTest
+  def test_1
+    Subversion.stubs(:revisions).returns(
+      begin
+        RSCM::Revisions.class_eval do
+          attr_accessor :revisions
+        end
+        RSCM::Revision.class_eval do
+          attr_accessor :files
+        end
+
+        file1 = RSCM::RevisionFile.new
+        file1.status = 'added'.upcase
+        file1.path = 'dir/file1'
+        file2 = RSCM::RevisionFile.new
+        file2.status = 'modified'.upcase
+        file2.path = 'dir/file2'
+
+        revision1 = RSCM::Revision.new
+        revision1.identifier = 1800
+        revision1.developer = 'tyler'
+        revision1.time = Time.utc(2007, 12, 01)
+        revision1.message = 'I say! Quite the storm, what!'
+        revision1.files = [file1, file2]
+
+        revision2 = RSCM::Revision.new
+        revision2.identifier = 1801
+        revision2.developer = 'tyler'
+        revision2.time = Time.utc(2007, 12, 02)
+        revision2.message = 'These Romans are crazy!'
+        revision2.files = [file2]
+
+        revisions = RSCM::Revisions.new
+        revisions.revisions = [revision1, revision2]
+      end
+    )
+    Subversion.stubs(:diff).returns("the diff")
+    
+    output = simulate_input(
+      'v' +     # View this changeset
+      "\n" +    # Continue to revision 1800
+      "\n"      # Try to continue, but of course there won't be any more revisions, so it will exit.
+    ) do
+      capture_output { SvnCommand.execute('revisions') }
+    end
+    puts output
+    require 'unroller'
+    #Unroller::trace :exclude_classes => /PP|PrettyPrint/ do
+
+    assert_equal <<-End, output
+Getting list of revisions for './' ...
+2 revisions found. Starting with most recent revision and going backward in time...
+
+2. r1800 | tyler | 2007-12-01 00:00:00
+I say! Quite the storm, what!
+
+A dir/file1
+M dir/file2
+View this changeset, Diff against specific revision, Grep the changeset, List or Edit revision properties, svn Cat all files from revision, grep the cat,
+  mark as Reviewed, edit log Message, or browse using Up/Down/Enter keys >
+
+
+
+
+
+
+
+
+
+
+Diffing 1799:1800...
+the diff
+
+2. r1800 | tyler | 2007-12-01 00:00:00
+I say! Quite the storm, what!
+
+A dir/file1
+M dir/file2
+View this changeset, Diff against specific revision, Grep the changeset, List or Edit revision properties, svn Cat all files from revision, grep the cat,
+  mark as Reviewed, edit log Message, or browse using Up/Down/Enter keys >  Next...
+
+1. r1801 | tyler | 2007-12-02 00:00:00
+These Romans are crazy!
+
+M dir/file2
+View this changeset, Diff against specific revision, Grep the changeset, List or Edit revision properties, svn Cat all files from revision, grep the cat,
+  mark as Reviewed, edit log Message, or browse using Up/Down/Enter keys >  Next...
+End
+    #end
+    assert_equal [
+      "svn status -u ./"    # To find head
+    ], Subversion.executed
+  end
+end
+
 
 #-----------------------------------------------------------------------------------------------------------------------------
 end #module Subversion

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: svn-command
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-04-05 00:00:00 -07:00
+  version: 0.2.1
+date: 2007-04-26 00:00:00 -07:00
 summary: A nifty wrapper command for Subversion's command-line svn client
 require_paths: 
 - lib
@@ -25,7 +25,11 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
-post_install_message: 
+post_install_message: |
+  ---------------------------------------------------------------------------------------------------
+  Please run _svn_command_post_install to finalize the installation.
+  ---------------------------------------------------------------------------------------------------
+
 authors: 
 - Tyler Rick
 files: