subwrap 0.4.0 → 0.5.0

data/ProjectInfo.rb

@@ -5,7 +5,7 @@ module Project
   PrettyName    = "Subwrap: Enhanced Subversion Command"
   Name          = "subwrap"
   RubyForgeName = "subwrap"
-  Version       = "0.4.0"
+  Version       = "0.5.0"
   Specification = Gem::Specification.new do |s|
     s.name    = Project::Name
     s.summary = "A nifty wrapper command for Subversion's command-line svn client"
@@ -20,8 +20,8 @@ module Project
     s.platform = Gem::Platform::RUBY
     s.add_dependency("colored")
     #s.add_dependency("escape")
-    s.add_dependency("facets")
-    s.add_dependency("quality_extensions")
+    s.add_dependency("facets", '> 2.4.4')
+    s.add_dependency("quality_extensions", '> 1.1.0')
     s.add_dependency("rscm")
     s.post_install_message = <<-End
 ---------------------------------------------------------------------------------------------------

data/Readme

@@ -102,7 +102,7 @@ New subcommands:
 
 == <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).
+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).
 
 It simply 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*.
 
@@ -126,7 +126,21 @@ It simply goes through each "unadded" file (each file reporting a status of <tt>
 
 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>svn revisions</tt> (revisions browser)
+== <tt>svn whats_new</tt> (replacement for <tt>svn update</tt>)
+
+Whereas <tt>svn update</tt> <i>only</i> updates (merges) with the latest changes and shows you which files were updated/etc., <tt>svn whats_new</tt>:
+* updates (merges) with the latest changes
+* shows you a summary of which files were updated/added/removed/conflict (:todo:)
+* shows the commit messages for each change_set [since you last ran this command :todo:]
+* shows the actual changes (diffs) that were made for every file in the 
+
+It's a lot like <tt>svn browse</tt> (and in fact shares most of the same code with it), except it's <i>non-interactive</i>, so you just run it and then sit back and watch all the pretty output -- which is a good thing, because doing a diff for each changeset can take a long time...
+
+Tip: When actively working on a project with lots of frequent committers, I like to keep a separate tab open in my terminal where I periodicaly run <tt>svn whats_new</tt>:
+* to grab the latest changes from everyone else on the team, and 
+* to skim through their changes to see what's changed.
+
+== <tt>svn browse</tt> (revisions browser)
 
 Lets you interactively browse through all revisions of a file/directory/repository (one at a time). For each revision, it will ask you what you want to do with it (view the changeset, edit revision properties, etc.).
 

data/lib/subwrap.rb

@@ -1,4 +1,6 @@
 # This is the auto-require, which I suppose never gets used any more thanks to RubyGems' annoying change
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__)))
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))    # This is mainly for development, to make sure the development version is used instead of loading the same file from the installed gem because the gem path happens to be earlier on in the $LOAD_PATH.
+$LOAD_PATH.uniq!
 require 'subwrap/subversion'
 Subversion

data/lib/subwrap/subversion.rb

@@ -10,7 +10,7 @@ require 'rubygems'
 gem 'facets'
 require 'facets/kernel/silence'
 silence_warnings do
-  require 'facets/kernel/load'
+  require 'facets/kernel/require_local'
   require 'facets/kernel/in'
   require 'facets/enumerable/uniq_by'
   require 'facets/fileutils/which'
@@ -54,6 +54,11 @@ module Subversion
   mattr_accessor :print_commands
   mguard_method :print_commands!, :@@print_commands
 
+  @@cached_commands = {}
+  @@cached_commands[:latest_revision] = {}
+
+  #-------------------------------------------------------------------------------------------------
+
   # Adds the given items to the repository. Items may contain wildcards.
   def self.add(*args)
     execute "add #{args.join ' '}"
@@ -322,18 +327,27 @@ module Subversion
     args = ['./'] if args.empty?
     execute "log #{args.join(' ')}"
   end
+
   # Returns the revision number for head.
-  def self.latest_revision(*args)
-    args = ['./'] if args.empty?
-    # The revision returned by svn status -u seems to be a pretty reliable way to get this. Does anyone know of a better way?
-    matches = /Status against revision:\s+(\d+)/m.match(status_against_server(args))
-    matches && matches[1]
+  def self.latest_revision(path = './')
+    (cached = @@cached_commands[:latest_revision][path]) and return cached
+    url = url(path)
+
+    #puts "Fetching latest revision from repository: #{url}"
+    result = latest_revision_for_path(url).to_i
+    @@cached_commands[:latest_revision][path] = result
+    result
   end
+
   # Returns the revision number for the working directory(/file?) specified by +path+
   def self.latest_revision_for_path(path)
     # The revision returned by svn info seems to be a pretty reliable way to get this. Does anyone know of a better way?
     matches = info(path).match(/^Revision: (\d+)/)
-    matches && matches[1]
+    if matches
+      matches[1].to_i
+    else
+      raise "Could not extract revision from #{info(path)}"
+    end
   end
 
   # Returns an array of RSCM::Revision objects
@@ -345,6 +359,7 @@ module Subversion
     args = (['-v'] + args)
     log_output = Subversion.log(*args)
     parser = ::RSCM::SubversionLogParser.new(io = StringIO.new(log_output), url = 'http://ignore.me.com')
+    # :todo: svn revisions -r 747 -- chops off line
     revisions = parser.parse_revisions
     revisions
   end
@@ -460,7 +475,9 @@ protected
       p command
     end
     if Subversion.print_commands
+      #puts '{print'
       p command
+      #puts '}print'
     end
 
     valid_options = [:capture, :exec, :popen]

data/lib/subwrap/subversion_extensions.rb

@@ -98,7 +98,7 @@ module Subversion
         if before_externals != ""
           if options[:files_only]
             before_externals = before_externals.strip.
-              gsub(/^ ?#{Status_flags.to_regexp_char_class} */, '') \
+              gsub(/^ ?#{Status_flags.to_regexp_char_class}..... /, '') \
               + "\n" 
           else
             before_externals = before_externals.strip.colorize_svn_status_lines + "\n" 

data/lib/subwrap/svn_command.rb

@@ -1,9 +1,10 @@
 # Tested by: ../../test/svn_command_test.rb
 
+require File.dirname(__FILE__) + '/../subwrap'
+
 require 'rubygems'
 
 require 'facets'
-#gem 'facets', '>=1.8.51'
 #require 'facets/more/command'    # Not until Facets includes my changes
 #require 'facets/kernel/load'
 #require 'facets/kernel/with'       # returning
@@ -23,6 +24,7 @@ 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/string/with_knowledge_of_color'
 require 'quality_extensions/module/attribute_accessors'
 #require 'quality_extensions/module/class_methods'
 
@@ -779,15 +781,14 @@ End
           [:__ignore_externals] => 0,
         }.merge(SvnCommand::C_standard_remote_command_options), self
       )
-      def __modified
-        @only_statuses << 'M'
-      end
+      def __modified;  @only_statuses << 'M'; end
+      def __added;     @only_statuses << 'A'; end
+      def __untracked; @only_statuses << '?'; end
+      def __deleted;   @only_statuses << 'D'; end
       alias_method :_M, :__modified
-
-      def __added
-        @only_statuses << 'A'
-      end
       alias_method :_A, :__added
+      alias_method :_?, :__untracked
+      alias_method :_D, :__deleted
 
       #document :__files_only do
       "Only list filenames, not statuses"
@@ -843,6 +844,10 @@ End
     end
 
     def update(*args)
+      directory = (args[0] ||= './')
+      revision_of_directory = Subversion.latest_revision_for_path(directory)
+      puts "(Note: The working copy '#{directory.white.bold}' was at #{('r' + revision_of_directory.to_s).magenta.bold} before updating...)"
+
       @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)) )
@@ -909,6 +914,8 @@ End
     #
     # Pass in a list of revisions/revision ranges ("134", "134:136", "134-136", and "134-136 139" are all valid)
     #
+    # :todo: How is this different from whats_new?
+    #
     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.)
@@ -1360,16 +1367,6 @@ End
       raise NotImplementedError
     end
 
-    #-----------------------------------------------------------------------------------------------------------------------------
-    # This is designed to be a convenient replacement to the svn update command for those who wish to not only see a *list* of 
-    # which files were updated as the update occurs but also wish to see *what changed* for each of those files.
-    # So this command will effectively do a diff on each updated file and show you what has changed (= "what's new").
-    module WhatsNew
-    end
-    def whats_new
-      SvnCommand.execute("revisions --whats-new --non-interactive")
-    end
-
     #-----------------------------------------------------------------------------------------------------------------------------
     # :todo: Pre-fetch svn diff in the background (fork the process) so you don't have to wait, in interactive mode.
     # :todo: When calling this command on a single file, 
@@ -1378,7 +1375,7 @@ End
     # :todo: add number aliases (1) for view changeset, etc. so you can use numpad exclusively
     # :todo: rename interactive mode to different name, s.a. browse_revisions
     # Add --grep option to non-interactively search all changesets returned for a pattern.
-    module Revisions
+    module ShowOrBrowseRevisions
       # We will pass all of these options through to 'svn log'
       Console::Command.pass_through({
           [:_q, :__quiet] => 0,
@@ -1387,7 +1384,7 @@ End
           [:__stop_on_copy] => 0,
           [:__incremental] => 0,
           [:__xml] => 0,
-          [:__limit] => 1,
+          #[:__limit] => 1,
         }.merge(SvnCommand::C_standard_remote_command_options), self
       )
 
@@ -1405,17 +1402,35 @@ End
       alias_method :_r,   :__revision
 
       #-------------------------------------------------------------------------
-      # :todo: Problem: I often forget to run this *before* doing an svn update. But as soon as I do an update, base is updated and now there is *nothing* new since last update.
-      # Possible solution: Keep a log of updates (at least all updates that use this wrapper) and let you go back to any previous update as your starting point if you've updated very recently and want to go back farther than that.
-      # (Or maybe .svn has a record of the previous update time somewhere that we can pick up?)
-      # Also, as soon as you do an svn revisions, it detects that it's out of date and forces an update, making it so that you can't repeat the command and get the same results.
-      #
+      def __all
+        @first_revision = '1'
+        @last_revision  = 'head'
+        @oldest_first_default = false
+        @limit = false
+      end
+
+      def __limit(limit)
+        @limit = limit
+      end
+
       def __since_last_update
-        @revisions = '%base%:head'
-        @newest_first_default = false
+        @first_revision = '%base%'
+        @last_revision  = 'head'
+        @oldest_first_default = true
       end
       alias_method :__from_base,   :__since_last_update
       alias_method :__since_base,  :__since_last_update
+
+      # :todo: Problem: I often forget to run this *before* doing an svn update. But as soon as I do an update, base is updated and now there is *nothing* new since last update.
+      # Possible solution: 
+      # :todo: Keep a log of updates (at least all updates that use this wrapper) and let you go back to any previous update as your starting point if you've updated very recently and want to go back farther than that.
+      # (Or maybe .svn has a record of the previous update time somewhere that we can pick up?)
+      #
+      def __whats_new
+        @first_revision = '%base%'
+        @last_revision  = 'head'
+        @oldest_first_default = true
+      end
       alias_method :__new,         :__since_last_update
       alias_method :__whats_new,   :__since_last_update
 
@@ -1425,14 +1440,23 @@ End
       #   Use chronic?
       # :todo:
       def __from(revision)
-        @revisions = "#{revision}:head"
-        @newest_first_default = false
+        @first_revision = revision
+        @last_revision  = 'head'
+        @oldest_first_default = true
       end
       alias_method :__since,   :__from
 
       def __back_to(revision)
-        @revisions = "#{revision}:head"
-        @newest_first_default = true
+        @first_revision = revision
+        @last_revision  = 'head'
+        @oldest_first_default = false
+      end
+
+      # :todo: if they're not at the root of the repo, this may not give them what they want
+      # they may want the last revisions for a specific file, in which case the latest_revision will likely not be the right revision number
+      def __last(revision_count)
+        @first_revision = Subversion.latest_revision - revision_count.to_i + 1
+        @last_revision  = Subversion.latest_revision
       end
 
       #-------------------------------------------------------------------------
@@ -1455,14 +1479,14 @@ End
       #-------------------------------------------------------------------------
       # Start at earlier revision and go forwards rather than starting at the latest revision
       def __oldest_first
-        @newest_first = false
+        @oldest_first = true
       end
       alias_method :__forward,         :__oldest_first
       alias_method :__forwards,        :__oldest_first
       alias_method :__chronological,   :__oldest_first
 
       def __newest_first
-        @newest_first = true
+        @oldest_first = false
       end
       alias_method :__reverse,     :__newest_first
       alias_method :__backwards,   :__newest_first
@@ -1476,6 +1500,10 @@ End
       end
       alias_method :__ni,     :__non_interactive
 
+      def __paged
+        @paged = true
+      end
+
       def __interactive
         @interactive = true
       end
@@ -1497,70 +1525,169 @@ End
       end
     end
     # :todo: what if they pass in *2* filenames?
-    def revisions(directory = './')
-      puts "Getting list of revisions for '#{directory.white.bold}' ..."
+    # See also: the implementation of revisions() in /usr/lib/ruby/gems/1.8/gems/rscm-0.5.1/lib/rscm/scm/subversion.rb
+    
+    module Revisions
+      def self.extended(base)
+        base.extend ShowOrBrowseRevisions
+      end
+    end
+    def play_revisions(directory = './')
+      @interactive = false
+      show_or_browse_revisions(directory)
+    end
+    alias_subcommand :changesets      => :revisions
+    alias_subcommand :show_log        => :revisions
+    alias_subcommand :show_revisions  => :revisions
+    alias_subcommand :show_changesets => :revisions
+
+    module Browse
+      def self.extended(base)
+        base.extend ShowOrBrowseRevisions
+      end
+    end
+    def browse(directory = './')
+      @interactive = true
+      show_or_browse_revisions(directory)
+    end
+    alias_subcommand :revisions         => :browse
+    alias_subcommand :browse            => :browse
+    alias_subcommand :browse_log        => :browse
+    alias_subcommand :browse_revisions  => :browse
+    alias_subcommand :browse_changesets => :browse
+    # Other so-far-rejected name ideas: list_commits, changeset_browser, log_browser, interactive_log
+
+    # This is designed to be a convenient replacement to the svn update command for those who wish to not only see a *list* of 
+    # which files were updated as the update occurs but also wish to see *what changed* for each of those files.
+    # So this command will effectively do a diff on each updated file and show you what has changed (= "what's new").
+    #
+    # Should this command run an update or do people want to run this command after an update??
+    # Nah... an update can be really slow... and they may have just done one...
+    module WhatsNew
+      def self.extended(base)
+        base.extend ShowOrBrowseRevisions
+      end
+    end
+    def whats_new(directory = './')
+      revision_of_directory = Subversion.latest_revision_for_path(directory)
+
+      #__whats_new
+      # (allow this to be overriden with, for example, a --since option)
+      @first_revision_default = revision_of_directory.to_s
+      @last_revision_default  = 'head'
+      @oldest_first_default = true
+
+      #puts "Updating..."
+      #Subversion.update(directory)  # silent
+      #Subversion.execute("update")
 
+      @interactive = false
+      show_or_browse_revisions(directory)
+    end
+
+    #-------------------------------------------------------------------------
+    protected
+    def show_or_browse_revisions(directory = './')
       #-----------------------------
       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! at least, each *directory* seems to have a different concept of base rev), 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...)
+      # By default, if you just do an svn log (which is what we do to get the metadata about each revision), svn will only show revisions up to and Last Changed Rev.
+      # So if there have been newer revisions since then, it won't show the log messages for them. 
+      # I can't think of a good reason why it shouldn't. I think it's a bug in the svn client.
+      #
+      # Also, it's possible for the Last Changed Rev of to be "out of date" even if you were the last committer! 
+      # If you commit file lib/foo.rb, the Last Changed Rev of lib/foo.rb may be 13 but the Last Changed Rev of . will still be 10 until you update '.'.
+      # In other words each *directory* has a different Last Changed Rev.
+      # 
+      # Anyway, to work around this bug, we explicitly get the head revision number from the server and pass that as the ending revision number to svn log.
+      # So in our example, we would pass -r 1:13 to svn log even when doing `svn browse .`, to ensure that we get information for all revisions
+      # all the way up to head (13).
+      #
+      # :todo: do the same for svn log
       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)
+        puts "The working copy '#{directory.white.bold}' appears to be out-of-date (#{revision_of_directory.to_s.magenta.bold}) with respect to the head revision (#{head.to_s.magenta.bold}). Just so ya know..."
+        #Subversion.update(directory)
       end
       #-----------------------------
 
       args = [directory]
-      #@revisions ||= '1:head'  # this was messing with --limit 5, making it start at 1 instead of most recent
-      if @revisions
-        @revisions.gsub! /%base%/, revision_of_directory
-        args.concat ['-r', @revisions] 
+
+      unless @revisions
+        @first_revision_default ||= '1' #'%base%'
+        @last_revision_default  ||= 'head'
+
+        @first_revision ||= @first_revision_default
+        @last_revision  ||= @last_revision_default
+        #@first_revision, @last_revision = @last_revision, @first_revision if @oldest_first
+        @revisions = "#{@first_revision}:#{@last_revision}"
       end
+      @revisions.gsub! /%base%/, revision_of_directory.to_s
+      args.concat ['-r', @revisions] 
 
-      @newest_first_default.nil? ? @newest_first_default = false : nil
-      @newest_first.nil? ? @newest_first = @newest_first_default : nil
+      @limit_default = nil #10
+      @limit = @limit_default               if @limit.nil? and @limit_default
+      args.concat ['--limit', @limit_default.to_s] if @limit
+
+      @oldest_first_default = true          if @oldest_first_default.nil?
+      @oldest_first = @oldest_first_default if @oldest_first.nil?
 
       @show_diffs ||= true if !@interactive
       @show_diffs_default ||= false
       @show_diffs ||= @show_diffs_default
 
       if @show_file_list.nil?
-        if directory != './' # They specified a (non-default) directory/file
-          @show_file_list = false
-        else
+        if directory == './' # They are using the default directory
           @show_file_list = true
+        else
+          @show_file_list = false
         end
       end
 
-      run_pager if !@interactive
+      #puts "@interactive=#{@interactive}"
+      #puts "@oldest_first=#{@oldest_first}"
+      #puts "@revisions=#{@revisions}"
+      #pp prepare_args(args)
 
       #-----------------------------
-      #pp prepare_args(args)
-      revisions = Subversion.revisions(*prepare_args(args))
+      puts "Getting revision details for '#{directory.green.bold}', revisions #{@revisions.magenta.bold} #{"(up to #{@limit} of them) " if @limit}(this may take a moment) ..."
+      #require 'unroller'
+      #Unroller.trace :dir_match => __FILE__ do
+      #Subversion.print_commands! do
+        revisions = Subversion.revisions(*prepare_args(args))
+      #end
+      #end
 
-      #puts "@newest_first=#{@newest_first}"
-      puts "#{revisions.length.to_s.bold} revisions found. Starting with #{(@newest_first ? 'most recent' : 'oldest').green.bold} revision and #{@newest_first ? 'going backward in time' :'going forward in time' }..."
-      revisions.instance_variable_get(:@revisions).reverse! if @newest_first
+      #-----------------------------
+      run_pager if !@interactive and @paged
+      puts "#{revisions.length.to_s.bold} revisions found. Starting with #{(@oldest_first ? 'oldest' : 'most recent').white.bold} revision and #{@oldest_first ? 'going forward in time' : 'going backward in time' }..."
+      #pp revisions.map {|r| [r.identifier, r.time]}
+      revisions.instance_variable_get(:@revisions).reverse! unless @oldest_first  # :todo: or just swap first and last when building @revisions? no, I think there are some cases when that wouldn't work...
       revision_ids = revisions.map(&:identifier)
 
       #-----------------------------------------------------------------------
       # The main loop through the array of revisions
-      target_rev = nil # revision_ids.first
+      #revisions.each do |revision|
+      i = 0
+      #target_rev = nil # revision_ids.first
       show_revision = true
+      show_menu = true
+      revision = revisions[i]
+      begin # rescue
+      loop do
+        show_revision = false if show_menu == false
 
-      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
+        counter = revision_ids.index(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
 
         #-----------------------------------------------------------------------
         show_diffs = proc {
@@ -1568,7 +1695,7 @@ End
           #puts "\n"*10
           puts
           puts((' '*100).green.underline)
-          print "Diffing #{revs_to_compare.min}:#{revs_to_compare.max}... ".bold
+          print "Diffing #{revs_to_compare.min.to_s.magenta.bold}:#{revs_to_compare.max.to_s.magenta.bold}... ".bold
           puts
           #Subversion.repository_root
           #Subversion.print_commands! do
@@ -1579,14 +1706,15 @@ End
         #-----------------------------------------------------------------------
         # Display the revision (number, date, description, files changed)
         if show_revision
-
           #puts((' '*100).green.underline)
           puts
-          puts((' '*100).on_green)
+          #puts((' '*100).on_green)
 
-          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 "#{revisions.length - revision_ids.index(rev)}. ".green.bold +
+          puts (
+              "r#{rev}".white.bold.on_green + (rev == head ? ' (head)'.bold.on_green : '') + 
+              " | #{revision.developer} | #{revision.time.strftime('%Y-%m-%d %H:%M:%S')}".white.bold.on_green
+            ).ljust_with_color(100, ' '.on_green)
           puts revision.message
           puts
           #pp revision
@@ -1605,32 +1733,28 @@ End
           show_diffs.call
         end
 
-        #-----------------------------------------------------------------------
-        # Display the menu
-        if @interactive
-          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/Space/Enter'.white.bold + ' keys > '
-          )
-        end
 
         #-----------------------------------------------------------------------
         # Get response from user and then act on it
-        begin # rescue
+        go = nil
+        catch :prev_or_next do
+        loop do
+          go = :nowhere
+
+          #-----------------------------------------------------------------------
+          # Display the menu
+          if @interactive and show_menu
+            print "r#{rev}".magenta.on_blue.bold + " (#{counter}/#{revisions.length})" + " (#{'?'.bold} for help)" + ' > '
+          end
+
+          #-----------------------------------------------------------------------
           if @interactive
             response = ""
             response = $stdin.getch.downcase
           else
-            response = "\n"
+            #response = "\n"
+            go = :next
+            throw :prev_or_next
           end
 
           # Escape sequence such as the up arrow key ("\e[A")
@@ -1649,6 +1773,25 @@ End
           end
 
           case response
+
+            when '?'   # Help
+              show_menu = false
+              puts
+              puts(
+                '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') + ', ' +
+                'browse using ' + 'Up/Down/Left/Right/Space/Enter'.white.bold + ' keys' + ', ' +
+                'Quit'.menu_item(:magenta)
+              )
+              show_revision = false # only show the menu
+
             when '1', 'v'  # View this changeset
               show_diffs.call
               show_revision = false # only show the menu
@@ -1755,42 +1898,69 @@ End
               end
               show_revision = false
 
-            when "\e[A" # Up
-              i = revision_ids.index(rev)
-              target_rev = revision_ids[i - 1]
+            when "\e[A", "\e\[D" # Previous (Up or Left)
+              #i = revision_ids.index(rev)
+              #target_rev = revision_ids[i - 1]
               puts " Previous..."
-              retry
+              go = :prev
+              throw :prev_or_next
+              #retry
 
-              
-            when /\n|\e\[B| / # Enter or Down or Space
+            when "\n", "\e\[B", "\e\[C", " " # Next (Enter or Down or Right or Space)
               # Skip / Do nothing with this file
               puts " Next..."
-              #show_revision = false  #?
-              next
+              go = :next
+              throw :prev_or_next
+              #next
+
+            when 'q' # Quit
+              raise Interrupt, "Quitting"
 
             else
               # Invalid option. Do nothing.
               #puts response.inspect
               puts
+              show_menu = false
               show_revision = false
 
           end # case response
 
-          redo # Until they tell us they're ready to move on...
+        end # loop until they tell us they're ready to move on...
+        end # catch :prev_or_next
 
-        rescue Interrupt
-          puts "\nGoodbye!"
-          return
-        end # rescue
-      end
+        case go
+        when :prev
+          if i-1 < 0
+            show_menu = false
+            puts "Can't go back -- already at first revision in set!".red
+          else
+            show_menu = show_revision = true
+            i -= 1
+          end
+        when :next
+          if i+1 > revisions.length-1
+            # We've reached the end
+            if @interactive
+              show_menu = false
+              puts "Can't go forward -- already at last revision in set!".red
+            else
+              break
+            end
+          else
+            show_menu = show_revision = true
+            i += 1
+          end
+        end
+        revision = revisions[i]
+
+      end # loop / revisions.each
+
+      rescue Interrupt
+        puts "\nGoodbye!"
+        return
+      end # rescue
     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
+    public
 
     #-----------------------------------------------------------------------------------------------------------------------------
     # Aliases

metadata

@@ -1,115 +1,126 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: subwrap
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2008-06-19 00:00:00 -07:00
-summary: A nifty wrapper command for Subversion's command-line svn client
-require_paths: 
-- lib
-email: rubyforge.org@tylerrick.com
-homepage: http://subwrap.rubyforge.org/
-rubyforge_project: subwrap
-description: This is a wrapper command for Subversion's command-line svn client that adds a few new subcommands.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.5.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: |
-  ---------------------------------------------------------------------------------------------------
-  You should now be able to run the subwrap command.
-  
-  IMPORTANT: If you want to replace the normal svn command with subwrap, please run 
-  sudo `which _subwrap_post_install` or check the Readme to find out how to manually add it to your path.
-  
-  Also, it is recommended that you install the termios gem so that you don't have to press enter
-  after selecting an option from the menu, but it will work without it.
-  ---------------------------------------------------------------------------------------------------
-
 authors: 
 - Tyler Rick
-files: 
-- lib/subwrap/subversion_extensions.rb
-- lib/subwrap/subversion.rb
-- lib/subwrap/svn_command.rb
-- lib/subwrap/pager.rb
-- lib/subwrap.rb
-- test/subversion_extensions_test.rb
-- test/svn_command_test.rb
-- test/subversion_test.rb
-- test/test_helper.rb
-- bin/subwrap
-- bin/rscm_test
-- bin/command_completion_for_subwrap
-- bin/svn
-- bin/_subwrap_post_install
-- ProjectInfo.rb
-- Readme
-test_files: 
-- test/subversion_extensions_test.rb
-- test/svn_command_test.rb
-- test/subversion_test.rb
-- test/test_helper.rb
-rdoc_options: 
-- --title
-- subwrap
-- --main
-- Readme
-- --line-numbers
-extra_rdoc_files: 
-- Readme
-executables: 
-- command_completion_for_subwrap
-- _subwrap_post_install
-- subwrap
-extensions: []
-
-requirements: []
+autorequire: 
+bindir: bin
+cert_chain: []
 
+date: 2008-09-17 00:00:00 -07:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: colored
+  type: :runtime
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: facets
+  type: :runtime
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 2.4.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: quality_extensions
+  type: :runtime
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 1.1.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: rscm
+  type: :runtime
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: "0"
     version: 
+description: This is a wrapper command for Subversion's command-line svn client that adds a few new subcommands.
+email: rubyforge.org@tylerrick.com
+executables: 
+- command_completion_for_subwrap
+- _subwrap_post_install
+- subwrap
+extensions: []
+
+extra_rdoc_files: 
+- Readme
+files: 
+- lib/subwrap/subversion_extensions.rb
+- lib/subwrap/subversion.rb
+- lib/subwrap/svn_command.rb
+- lib/subwrap/pager.rb
+- lib/subwrap.rb
+- test/subversion_extensions_test.rb
+- test/svn_command_test.rb
+- test/subversion_test.rb
+- test/test_helper.rb
+- bin/subwrap
+- bin/rscm_test
+- bin/command_completion_for_subwrap
+- bin/svn
+- bin/_subwrap_post_install
+- ProjectInfo.rb
+- Readme
+has_rdoc: true
+homepage: http://subwrap.rubyforge.org/
+post_install_message: |
+  ---------------------------------------------------------------------------------------------------
+  You should now be able to run the subwrap command.
+  
+  IMPORTANT: If you want to replace the normal svn command with subwrap, please run 
+  sudo `which _subwrap_post_install` or check the Readme to find out how to manually add it to your path.
+  
+  Also, it is recommended that you install the termios gem so that you don't have to press enter
+  after selecting an option from the menu, but it will work without it.
+  ---------------------------------------------------------------------------------------------------
+
+rdoc_options: 
+- --title
+- subwrap
+- --main
+- Readme
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: subwrap
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A nifty wrapper command for Subversion's command-line svn client
+test_files: 
+- test/subversion_extensions_test.rb
+- test/svn_command_test.rb
+- test/subversion_test.rb
+- test/test_helper.rb