pvn 0.0.8 → 0.0.9

data/lib/pvn/app/runner.rb

@@ -11,6 +11,7 @@ require 'pvn/log/command'
 require 'pvn/pct/command'
 require 'pvn/status/command'
 require 'pvn/diff/command'
+require 'pvn/seek/command'
 
 # the old ones:
 # require 'pvn/diff/diffcmd'
@@ -31,6 +32,7 @@ module PVN::App
                     PVN::Pct::Command,
                     PVN::Status::Command,
                     PVN::Diff::Command,
+                    PVN::Seek::Command,
                     # DescribeCommand, 
                     # WhereCommand,
                     # UndeleteCommand,

data/lib/pvn/command/command.rb

@@ -32,11 +32,6 @@ module PVN::Command
         getdoc.summary = smry
       end
 
-      ### $$$ remove this:
-      def options opts
-        getdoc.options.concat opts
-      end
-
       def optscls
         getdoc.options.concat optset.options
       end

data/lib/pvn/diff/{path_revision.rb → change.rb}

@@ -7,7 +7,7 @@ module PVN; module Diff; end; end
 
 # A Path Revision is the change to a path within a changelist. 
 module PVN::Diff
-  class PathRevision
+  class Change
     include Loggable
     
     attr_reader :revision

data/lib/pvn/diff/changed_paths.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/diff/log_paths'
+require 'pvn/diff/status_paths'
+require 'pvn/diff/local_path'
+require 'pvn/revision/range'
+
+module PVN::Diff
+  # represents both LogPaths and StatusPaths
+  class ChangedPaths
+    include Loggable
+
+    def initialize paths
+      @paths = paths
+    end
+
+    def diff_revision_to_working_copy revision, whitespace
+      fromrev = revision.from.value
+
+      info "revision: #{revision}".cyan
+      rev = PVN::Revision::Range.new revision.to_s, 'HEAD'
+      info "rev: #{rev}".cyan
+
+      logpaths = LogPaths.new rev, @paths
+      name_to_logpath = logpaths.to_map
+
+      statuspaths = StatusPaths.new revision, @paths
+      name_to_statuspath = statuspaths.to_map
+
+      ### $$$ log names and status names should have a Name class
+
+      names = Set.new
+      names.merge name_to_logpath.keys.collect { |name| name[1 .. -1] }
+      info "names: #{names.inspect}"
+
+      names.merge name_to_statuspath.keys
+      info "names: #{names.inspect}"
+
+      names.sort.each do |name|
+        info "name: #{name}"
+
+        ### $$$ silliness because I don't have Diff::Name integrated:
+        logname = '/' + name
+        
+        logpath = name_to_logpath[logname]
+        info "logpaths: #{logpaths}"
+
+        stpath = name_to_statuspath[name]
+        info "stpath: #{stpath}"
+
+        frrev = nil
+
+        if logpath
+          chgrevs = logpath.revisions_later_than fromrev
+          logpath.diff_revision_to_working_copy revision, whitespace
+        else
+          # it's a local file only
+          stpath.show_diff whitespace
+        end
+      end
+    end
+  end
+end

data/lib/pvn/diff/differ.rb

@@ -16,68 +16,8 @@ module PVN::Diff
     attr_reader :revision
     
     def initialize options
-    end
-
-    def to_revision_string rev
-      rev ? "revision #{rev}" : "working copy"
-    end
-
-    def write_to_temp entry, lines
-      Tempfile.open('pvn') do |to|
-        topath = to.path
-        to.puts lines
-        to.close
-        cmd = "diff -u"
-        label = " -L '#{entry.path} (revision 0)'"
-        2.times do
-          cmd << label
-        end
-        cmd << " #{frpath}"
-        cmd << " #{entry.path}"
-        IO.popen(cmd) do |io|
-          puts io.readlines
-        end
-      end
-    end
-
-    def run_diff_command displaypath, fromrev, torev, frompath, topath
-      cmd = "diff -u"
-      if whitespace
-        cmd << " -w"
-      end
-
-      [ fromrev, torev ].each do |rev|
-        revstr = to_revision_string rev
-        cmd << " -L '#{displaypath}\t(#{revstr})'"
-      end
-      cmd << " #{frompath}"
-      cmd << " #{topath}"
-
-      info "cmd: #{cmd}"
-
-      $io.puts "Index: #{displaypath}"
-      $io.puts "==================================================================="
-      IO.popen(cmd) do |io|
-        $io.puts io.readlines
-      end
-    end
-
-    def run_diff displaypath, fromlines, fromrev, tolines, torev
-      Tempfile.open('pvn') do |from|
-        if fromlines
-          from.puts fromlines
-        end
-        from.close
-
-        Tempfile.open('pvn') do |to|
-          if tolines
-            to.puts tolines
-          end
-          to.close
-          
-          run_diff_command displaypath, fromrev, torev, from.path, to.path
-        end
-      end
+      @whitespace = options.whitespace
+      @options = options
     end
   end
 end

data/lib/pvn/diff/local_differ.rb

@@ -4,6 +4,8 @@
 require 'pvn/io/element'
 require 'pvn/diff/options'
 require 'pvn/diff/differ'
+require 'pvn/diff/local_path'
+# require 'pvn/diff/status_path'
 
 module PVN::Diff
   class LocalDiffer < Differ
@@ -18,29 +20,16 @@ module PVN::Diff
       # we sort only the sub-entries, so the order in which paths were specified
       # is preserved
 
-      @whitespace = options.whitespace
-
       paths.each do |path|
         elmt = PVN::IO::Element.new :local => path
         entries = elmt.find_files_by_status
-        
         allentries.concat entries.sort_by { |n| n.path }
       end
 
       allentries.each do |entry|
-        show_entry entry
-      end
-    end
-
-    def show_entry entry
-      info "entry: #{entry.inspect}"
-      case entry.status
-      when 'modified'
-        show_as_modified entry
-      when 'deleted'
-        show_as_deleted entry
-      when 'added'
-        show_as_added entry
+        next if entry.status == 'unversioned'
+        path = LocalPath.new entry
+        path.show_diff @whitespace
       end
     end
 
@@ -48,52 +37,5 @@ module PVN::Diff
     def use_cache?
       super && !against_head?
     end
-
-    def against_head?
-      @options.change.value.nil? && @options.revision.head?
-    end
-
-    def read_working_copy entry
-      pn = Pathname.new entry.path
-      pn.readlines
-    end
-
-    def create_element entry
-      PVN::IO::Element.new :local => entry.path
-    end
-
-    def cat elmt
-      elmt = PVN::IO::Element.new :local => elmt.local
-      elmt.cat nil, :use_cache => false
-    end
-
-    def show_as_added entry
-      fromlines = nil
-      tolines = read_working_copy entry
-
-      run_diff entry.path, fromlines, 0, tolines, 0
-    end
-
-    def get_latest_revision elmt
-      svninfo = elmt.get_info
-      svninfo.revision
-    end
-
-    def show_as_deleted entry
-      elmt = create_element entry
-
-      fromrev = get_latest_revision elmt
-      lines = cat elmt
-
-      run_diff entry.path, lines, fromrev, nil, nil
-    end
-    
-    def show_as_modified entry
-      elmt = create_element entry
-      remotelines = cat elmt
-      fromrev = get_latest_revision elmt
-      wclines = read_working_copy entry
-      run_diff entry.path, remotelines, fromrev, wclines, nil
-    end
   end
 end

data/lib/pvn/diff/local_path.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/diff/path'
+
+module PVN::Diff
+  class LocalPath < Path
+    # that's a Status::Entry
+    def initialize entry
+      @entry = entry
+      @elmt = create_element
+      name = entry.path
+      action = SVNx::Action.new @entry.status
+      revision = action.added? ? 0 : @elmt.get_info.revision
+      super name, revision, action, nil
+    end
+
+    def show_diff whitespace = nil
+      case @entry.status
+      when 'modified'
+        show_as_modified whitespace
+      when 'deleted'
+        show_as_deleted
+      when 'added'
+        show_as_added
+      end
+    end
+
+    ### $$$ todo: integrate these, from old diff/diffcmd
+    def use_cache?
+      super && !against_head?
+    end
+
+    def read_working_copy
+      pn = Pathname.new @entry.path
+      pn.readlines
+    end
+
+    def create_element
+      PVN::IO::Element.new :local => @entry.path
+    end
+
+    def get_latest_revision
+      svninfo = @elmt.get_info
+      svninfo.revision
+    end
+
+    def show_as_added
+      fromlines = nil
+      tolines = read_working_copy
+      run_diff @entry.path, fromlines, 0, tolines, 0, nil
+    end
+
+    def show_as_deleted
+      fromrev = changes[0].revision
+      # revision = nil; use_cache = false
+      lines = @elmt.cat nil, false
+      run_diff @entry.path, lines, fromrev, nil, nil, nil
+    end
+    
+    def show_as_modified whitespace
+      remotelines = @elmt.cat nil, false
+      fromrev = changes[0].revision
+      wclines = read_working_copy
+      run_diff @entry.path, remotelines, fromrev, wclines, nil, whitespace
+    end
+  end
+end

data/lib/pvn/diff/log_path.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/diff/path'
+
+module PVN::Diff
+  # this is a path wrapping a log entry; it could also be a RemotePath or a
+  # RepoPath.
+  class LogPath < Path
+    
+    # the "path" parameter is the displayed name; "logpath" is the LogPath.
+    # These are in the process of refactoring.
+    def show_as_modified elmt, path, fromrev, torev, revision, whitespace
+      fromlines = elmt.cat fromrev
+      tolines = elmt.cat torev
+      fromrev = revision.from.value.to_i
+      run_diff path, fromlines, fromrev, tolines, revision.to, whitespace
+    end
+
+    def show_as_added elmt, path, revision, whitespace
+      info "path: #{path}".on_blue
+      tolines = elmt.cat revision.to
+      info "tolines: #{tolines}".blue
+      run_diff path, nil, 0, tolines, revision.to, whitespace
+    end
+
+    def show_as_deleted elmt, path, revision, whitespace
+      fromrev = revision.from.value.to_i
+      fromlines = elmt.cat fromrev
+      run_diff path, fromlines, fromrev, nil, revision.to, whitespace
+    end
+    
+    # log entries have names of the form /foo/bar.rb, relative to the URL.
+    def get_display_path
+      name[1 .. -1]
+    end
+
+    def diff_revision_to_revision revision, whitespace
+      logpath = self
+      info "name: #{name}"
+
+      # all the paths will be the same, so any can be selected (actually, a
+      # logpath should have multiple changes)
+      svnpath = url + name
+      info "svnpath: #{svnpath}"
+      elmt = PVN::IO::Element.new :svn => svnpath
+
+      displaypath = get_display_path
+
+      info "revision.from: #{revision.from}".cyan
+
+      rev_change = changes.detect do |chg| 
+        revarg = PVN::Revision::Argument.new chg.revision
+        revarg > revision.from
+      end
+
+      info "rev_change: #{rev_change}".green
+
+      # we ignore unversioned logpaths
+      
+      # I'm sure there is a bunch of permutations here, so this is probably
+      # overly simplistic.
+      action = rev_change.action
+      
+      case
+      when action.added?
+        show_as_added elmt, displaypath, revision, whitespace
+      when action.deleted?
+        show_as_deleted elmt, displaypath, revision, whitespace
+      when action.modified?
+        firstrev = changes[0].revision
+        lastrev = changes[-1].revision
+        fromrev, torev = if firstrev == lastrev
+                           [ revision.from.value.to_i - 1, revision.to ]
+                         else
+                           [ firstrev.to_i - 1, lastrev ]
+                         end
+        show_as_modified elmt, displaypath, firstrev, torev, revision, whitespace
+      end
+    end
+
+    def get_diff_revision change, revision
+      info "change: #{change}"
+      info "revision: #{revision}"
+      # find the first revision where logpath was in svn, no earlier than the
+      # revision.from value
+      if change.action.added?
+        return change.revision.to_i
+      elsif change.revision.to_i >= revision.from.value
+        return revision.from.value
+      else
+        nil
+      end
+    end
+
+    def diff_revision_to_working_copy revision, whitespace
+      fromrev = revision.from.value.to_i
+
+      ### $$$ this doesn't handle the case where a file has been added, then
+      ### modified.
+
+      change = revisions_later_than(fromrev).first
+      info "change: #{change}".red
+
+      # revision should be a class here, not a primitive
+      diffrev = get_diff_revision change, revision
+      
+      display_path = get_display_path
+
+      pn = Pathname.new display_path
+
+      svnpath = url + name
+      info "svnpath: #{svnpath}"
+      elmt = PVN::IO::Element.new :svn => svnpath
+
+      if change.action.added?
+        show_as_added elmt, display_path, revision, whitespace
+      else
+        fromlines = elmt.cat diffrev
+        info "fromlines.size: #{fromlines.size}"
+        pp fromlines
+
+        tolines = pn.readlines
+        info "tolines.size: #{tolines.size}"
+        pp tolines
+
+        run_diff display_path, fromlines, diffrev, tolines, nil, whitespace
+      end
+    end
+
+    def is_revision_later_than? revision
+      revisions_later_than(revision).first
+    end
+
+    def revisions_later_than revision
+      changes.select do |chg|
+        info "chg: #{chg.revision.inspect}"
+        x = PVN::Revision::Argument.new chg.revision
+        y = PVN::Revision::Argument.new revision
+        x > y
+      end
+    end
+  end
+end

data/lib/pvn/diff/log_paths.rb

@@ -3,7 +3,7 @@
 
 require 'pvn/io/element'
 require 'pvn/diff/paths'
-require 'pvn/diff/path'
+require 'pvn/diff/log_path'
 
 module PVN::Diff
   # represents the log entries from one revision through another.
@@ -30,17 +30,27 @@ module PVN::Diff
       action = logentrypath.action
       url = pathinfo.url
 
-      info "action: #{action}".blue
+      info "action: #{action}"
       
       path = @elements.detect { |element| element.name == name }
       if path
-        info "path: #{path}".on_blue
-        path.add_revision logentry.revision, action
+        info "path: #{path}"
+        path.add_change logentry.revision, action
       else
-        path = Path.new(name, logentry.revision, action, url)
-        info "path: #{path}".on_cyan
+        path = LogPath.new(name, logentry.revision, action, url)
+        info "path: #{path}"
         @elements << path
       end
     end
+
+    def diff_revision_to_revision revision, whitespace
+      name_to_logpath = to_map
+
+      name_to_logpath.sort.each do |name, logpath|
+        if logpath.is_revision_later_than? revision.from.value
+          logpath.diff_revision_to_revision revision, whitespace
+        end
+      end
+    end
   end
 end

data/lib/pvn/diff/name.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'riel'
+
+module PVN; module Diff; end; end
+
+module PVN::Diff
+  # represents names in LogPaths and StatusPaths.
+  ### $$$ todo: integrate with those classes.
+  class Name
+    include Loggable
+    
+    def initialize namestr
+      @namestr = namestr
+    end
+
+    def to_s
+      @namestr
+    end
+  end
+end

data/lib/pvn/diff/path.rb

@@ -2,7 +2,7 @@
 # -*- ruby -*-
 
 require 'svnx/action'
-require 'pvn/diff/path_revision'
+require 'pvn/diff/change'
 
 module PVN; module Diff; end; end
 
@@ -11,32 +11,20 @@ module PVN::Diff
     include Loggable
     
     attr_reader :name
-    # attr_reader :revisions
-    attr_reader :action
     attr_reader :url
-    ### $$$ this will be renamed revisions, when the old one is gone.
-    attr_reader :path_revisions
+    attr_reader :changes
     
     # that's the root url
     def initialize name, revision, action, url
       @name = name
-      @revisions = Array.new
-      @path_revisions = Array.new
-      add_revision revision, action
-      @action = action.kind_of?(SVNx::Action) || SVNx::Action.new(action)
+      @changes = Array.new
+      add_change revision, action
       @url = url
     end
 
-    def add_revision rev, action
-      info "rev: #{rev}".on_green
-      if rev.kind_of?(Array)
-        rev.each do |rv|
-          @revisions << to_revision(rv)
-        end
-      else
-        @revisions << to_revision(rev)
-      end
-      @path_revisions << PathRevision.new(to_revision(rev), action)
+    def add_change rev, action
+      info "rev: #{rev}"
+      @changes << Change.new(to_revision(rev), action)
     end
 
     def to_revision rev
@@ -48,5 +36,49 @@ module PVN::Diff
     def to_s
       inspect
     end
+    
+    def to_revision_string rev
+      rev ? "revision #{rev}" : "working copy"
+    end
+
+    def run_diff_command displaypath, fromrev, torev, frompath, topath, whitespace
+      cmd = "diff -u"
+      if whitespace
+        cmd << " -w"
+      end
+
+      [ fromrev, torev ].each do |rev|
+        revstr = to_revision_string rev
+        cmd << " -L '#{displaypath}\t(#{revstr})'"
+      end
+      cmd << " #{frompath}"
+      cmd << " #{topath}"
+
+      info "cmd: #{cmd}"
+
+      $io.puts "Index: #{displaypath}"
+      $io.puts "==================================================================="
+      IO.popen(cmd) do |io|
+        $io.puts io.readlines
+      end
+    end
+
+    def run_diff displaypath, fromlines, fromrev, tolines, torev, whitespace
+      Tempfile.open('pvn') do |from|
+        if fromlines
+          from.puts fromlines
+        end
+        from.close
+
+        Tempfile.open('pvn') do |to|
+          if tolines
+            to.puts tolines
+          end
+          to.close
+          
+          run_diff_command displaypath, fromrev, torev, from.path, to.path, whitespace
+        end
+      end
+    end
   end
 end