pvn 0.0.8 → 0.0.9

data/lib/pvn/diff/repository_differ.rb

@@ -1,12 +1,11 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'pvn/io/element'
 require 'pvn/diff/options'
 require 'pvn/diff/differ'
 require 'pvn/diff/log_paths'
 require 'pvn/diff/status_paths'
-require 'pvn/diff/revision'
+require 'pvn/diff/changed_paths'
 
 module PVN::Diff
   class RepositoryDiffer < Differ
@@ -16,138 +15,31 @@ module PVN::Diff
     attr_reader :revision
     
     def initialize options
+      super
+      
       paths = options.paths
       paths = %w{ . } if paths.empty?
 
       # we sort only the sub-entries, so the order in which paths were specified is preserved
 
-      @whitespace = options.whitespace
       rev = options.revision
       change = options.change
 
-      if rev[1].nil? || rev[1].to == :working_copy
-        # rev[1] = "BASE"
-      end
-
-      fromrev = if change 
-                  change.to_i - 1
-                else
-                  rev[0].to_i
-                end
-
-      @revision = RevisionRange.new change, rev
+      # this is for getting revisions only later than the given revision
+      # (argument); this only handling revision numbers (not dates) for now.
 
-      logpaths = LogPaths.new @revision, paths
-      name_to_logpath = logpaths.to_map
-
-      name_to_logpath.sort.each do |name, logpath|
-        if is_revision_later_than? logpath, fromrev
-          diff_logpath logpath
-        end
-      end
-
-      return if true
+      rev = change ? [ change.to_i - 1, change.to_i ] : options.revision
+      info "rev: #{rev}"
+      @revision = PVN::Revision::Range.new(*rev)
+      info "@revision: #{@revision}"
 
+      # this indicates that this should be split into two classes:
       if @revision.working_copy?
-        ### $$$ not handled yet
-        statuspaths = StatusPaths.new @revision, paths
-        info "statuspaths: #{statuspaths}".on_blue
-        statuspaths.each do |stpath|
-          info "stpath: #{stpath}".on_green
-          # diff_status_path stpath
-        end
-        # name_to_logpath = logpaths.to_map
-      end        
-    end
-
-    def is_revision_later_than? logpath, revision
-      logpath.path_revisions.detect do |rev|
-        info "rev.revision: #{rev.revision.inspect}".cyan
-        x = PVN::Revision::Argument.new rev.revision
-        y = PVN::Revision::Argument.new revision
-        x > y
-      end
-    end
-
-    def show_as_modified elmt, path, fromrev, torev
-      info "elmt: #{elmt}"
-      fromlines = elmt.cat fromrev
-      tolines = elmt.cat torev
-      fromrev = @revision.from.value.to_i
-      run_diff path, fromlines, fromrev, tolines, @revision.to
-    end
-
-    def show_as_added elmt, path
-      info "elmt: #{elmt}"
-      tolines = elmt.cat @revision.to
-      run_diff path, nil, 0, tolines, @revision.to
-    end
-
-    def show_as_deleted elmt, path
-      info "elmt: #{elmt}"
-      fromrev = @revision.from.value.to_i
-      fromlines = elmt.cat fromrev
-      run_diff path, fromlines, fromrev, nil, @revision.to
-    end
-    
-    def diff_logpath logpath
-      info "logpath.name: #{logpath.name}"
-      name = logpath.name
-
-      revisions = logpath.path_revisions
-      
-      # all the paths will be the same, so any can be selected (actually, a
-      # logpath should have multiple revisions)
-      svnurl = logpath.url
-      info "svnurl: #{svnurl}"
-      
-      svnpath = svnurl + name
-      info "svnpath: #{svnpath}"
-      elmt = PVN::IO::Element.new :svn => svnpath
-
-      displaypath = name[1 .. -1]
-      info "displaypath: #{displaypath}"
-
-      firstrev = revisions[0].revision
-      info "firstrev: #{firstrev}".yellow
-      lastrev = revisions[-1].revision
-
-      action = logpath.action
-      info "action: #{action}".on_blue
-
-      pathrevs = logpath.path_revisions
-      info "pathrevs: #{pathrevs}".green
-
-      info "@revision.from: #{@revision.from}".cyan
-
-      pathrevs = logpath.path_revisions.select do |rev| 
-        info "rev.revision: #{rev.revision.inspect}".cyan
-        revarg = PVN::Revision::Argument.new rev.revision
-        revarg > @revision.from
-      end
-
-      info "pathrevs: #{pathrevs}".green
-
-      # we ignore unversioned logpaths
-      
-      # I'm sure there is a bunch of permutations here, so this is probably
-      # overly simplistic.
-      firstaction = pathrevs[0].action
-      
-      case
-      when firstaction.added?
-        show_as_added elmt, displaypath
-      when firstaction.deleted?
-        show_as_deleted elmt, displaypath
-      when firstaction.modified?
-        fromrev, torev = if firstrev == lastrev
-                           [ @revision.from.value.to_i - 1, @revision.to ]
-                         else
-                           [ firstrev.to_i - 1, lastrev ]
-                         end
-        info "firstrev: #{firstrev.inspect}"
-        info "torev: #{torev.inspect}"
-        show_as_modified elmt, displaypath, firstrev, torev
+        chgpaths = ChangedPaths.new paths
+        chgpaths.diff_revision_to_working_copy @revision, @whitespace
+      else
+        logpaths = LogPaths.new @revision, paths
+        logpaths.diff_revision_to_revision @revision, @whitespace
       end
     end
   end

data/lib/pvn/diff/status_paths.rb

@@ -6,7 +6,6 @@ require 'pvn/diff/path'
 require 'pvn/diff/paths'
 
 module PVN::Diff
-  # represents the log entries from one revision through another.
   class StatusPaths < Paths
     include Loggable
 
@@ -19,49 +18,28 @@ module PVN::Diff
 
     def add elmt, url
       status = elmt.find_files_by_status
-      info "status: #{status}"
       status.entries.each do |entry|
         # we don't care about unversioned entries for diffing.
         next if entry.status == 'unversioned'
         
-        info "@revision: #{@revision}"
-        info "entry: #{entry}"
         # svn log prepends /; svn status does not
         name = '/' + entry.path
-        info "name: #{name}"
         rev = :working_copy
-        info "rev: #{rev}"
 
         # what Status::Entry calls a status, we call an action, unifying it with
         # svn log representation.
         action = entry.status
-        info "action: #{action}"
-        revisions = get_status_revisions entry
-        info "revisions: #{revisions}"
-
-        info "status.revision: #{entry.status_revision}"
-
-        @elements << Path.new(name, entry.status_revision, action, url)
+        info "entry.status_revision: #{entry.status_revision}"
+        path = LocalPath.new entry
+        @elements << path
       end
     end
-
-    # this may belong in Status::Entry
+    
+    ### $$$ this may belong in Status::Entry
     def get_status_revisions status_entry
       # the printing revision in svn (svn diff -r20) are confusing, but this
       # is what it looks like:
 
-      # when a file is added locally
-      #     the revisions are (0, 0)
-      # when a file is modified:
-      #     if the file is modified in other revisions since givenfromrev
-      #         the revision is (most recent rev, working copy)
-      #     otherwise
-      #         the revision is (previous revision, working copy)
-      # when a file is deleted:
-      #     the revision is (given from rev, working copy)
-
-      # okay, summary #2:
-
       # if a file is modified,
       #     if the file existed at fromrev
       #         it is compared with fromrev

data/lib/pvn/pct/differ.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'pvn/pct/diffcount'
+require 'pvn/util/diffcount'
 
 module PVN::Pct
   class Differ

data/lib/pvn/pct/local_differ.rb

@@ -3,7 +3,6 @@
 
 require 'pvn/io/element'
 require 'svnx/cat/command'
-require 'pvn/pct/diffcount'
 require 'pvn/pct/differ'
 
 module PVN::Pct

data/lib/pvn/pct/repository_differ.rb

@@ -2,25 +2,24 @@
 # -*- ruby -*-
 
 require 'pvn/io/element'
-require 'pvn/pct/diffcount'
 require 'pvn/pct/differ'
+require 'pvn/revision/range'
 
 module PVN::Pct
   class RepositoryDiffer < Differ
-    ### $$$ this belongs in Revision
+    # 
     def get_from_to_revisions rev
-      if rev.kind_of? Array
-        if rev.size == 1
-          if md = Regexp.new('(.+):(.+)').match(rev[0])
-            return [ md[1], md[2] ]
-          else
-            return [ (rev[0].to_i - 1).to_s, rev[0] ]
-          end
+      fromrev = nil
+      torev = nil
+      
+      if rev.size == 1
+        if md = Regexp.new('(.+):(.+)').match(rev[0])
+          return [ md[1], md[2] ]
         else
-          return [ rev[0], rev[1] ]
+          return [ (rev[0].to_i - 1).to_s, rev[0] ]
         end
       else
-        info "rev: #{rev}".bold.white.on_red
+        return [ rev[0], rev[1] ]
       end
     end
     
@@ -28,14 +27,18 @@ module PVN::Pct
       diff_counts = Array.new
 
       revision = options.revision
+
+      # revision -r20 is like diff -c20:
+      info "revision: #{revision}".bold.yellow
+      fromrev, torev = get_from_to_revisions revision
+      info "fromrev: #{fromrev}".yellow
+      info "torev: #{torev}".yellow
       
       elmt = PVN::IO::Element.new :local => path
-      modified = elmt.find_modified_entries revision
+      modified = elmt.find_modified_entries [ fromrev + ':' + torev ]
 
       modnames = modified.collect { |m| m.name }.sort.uniq
 
-      fromrev, torev = get_from_to_revisions revision
-
       reporoot = elmt.repo_root
 
       direlmt = PVN::IO::Element.new :local => '.'

data/lib/pvn/seek/command.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/seek/options'
+require 'pvn/command/command'
+
+module PVN::Seek
+  class Command < PVN::Command::Command
+
+    subcommands [ "seek" ]
+    description "Searches through revisions for a pattern match."
+    usage       "[OPTIONS] FILE..."
+    summary   [ "Goes through a set of revisions, looking for when a pattern",
+                "first matched a line within a file." ]
+    
+    # summary   [ "Goes through a set of revisions, looking for when a pattern",
+    #             "matched (the default), or when a pattern does not match.",
+    #             "This command therefore shows when a file changed to add",
+    #             "or remove something such as a method." ]
+    
+    optscls
+
+    example "pvn seek 'raise \w+Exception' foo.rb", "Shows when 'raise \w+Exception was added, through all revisions."
+    # example "pvn seek -r137:211 'raise \w+Exception' foo.rb", "As above, but only between revisions 137 and 211."
+    # example "pvn seek --no-match 'void\s+reinitialize()' *.java", "Looks through Java files for when 'void reinitialize() does _not_ match."
+
+    def init options
+      info "options: #{options.inspect}".red
+
+      paths = options.paths
+
+      pattern = paths.shift
+      info "pattern: #{pattern}"
+
+      paths = %w{ . } if paths.empty?
+      info "paths: #{paths}".cyan
+
+      # can handle only one path for now
+
+      @path = paths[0]
+      
+      # should I embed glark in pvn?
+
+      entries = find_log_entries @path
+      seek entries, pattern, 0, entries.size
+    end
+
+    def matches? contents, pattern
+      contents.each_with_index do |line, idx|
+        # info "line: #{line}".cyan
+        if line.index pattern
+          info "line: #{line}".red
+          return [ idx, line ]
+        end
+      end
+      false
+    end
+
+    def cat revision
+      info "path: #{@path}"
+      info "revision: #{revision}"
+      catargs = SVNx::CatCommandArgs.new :path => @path, :use_cache => false, :revision => revision
+      cmd = SVNx::CatCommand.new catargs
+      cmd.execute
+    end
+
+    def seek entries, pattern, from, to
+      info "from: #{from}".cyan
+      info "to: #{to}".cyan
+
+      midpt = from + (to - from) / 2
+      return nil if midpt + 1 >= to
+
+      entry = entries[midpt]
+        
+      lines = cat entry.revision
+      info "entry.revision: #{entry.revision}"
+      info "lines: #{lines.size}"
+      
+      if ref = matches?(lines, pattern)
+        prevrev = entries[midpt + 1].revision
+        info "prevrev: #{prevrev}"
+        prevlines = cat prevrev
+        info "prevlines: #{prevlines.size}"
+        
+        if !matches?(prevlines, pattern)
+          info "ref: #{ref}"
+          $io.puts "path: #{@path} revision: #{entry.revision}"
+          $io.puts "#{@path}:#{ref[0]}: #{ref[1]}"
+        else
+          seek entries, pattern, midpt, to
+        end
+      else
+        seek entries, pattern, from, midpt + 1
+      end
+    end
+
+    ### $$$ this is sliced from Log::Command, from which many options will apply
+    ### here (limit, user, revision)
+    def find_log_entries path
+      cmdargs = Hash.new
+      cmdargs[:path] = path
+      cmdargs[:use_cache] = false
+
+      logargs = SVNx::LogCommandArgs.new cmdargs
+      elmt    = PVN::IO::Element.new :local => path || '.'
+      log     = elmt.log logargs
+      entries = log.entries
+    end
+  end
+end

data/lib/pvn/seek/options.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/revision/revision_regexp_option'
+require 'pvn/command/options'
+
+module PVN::Seek
+  class MatchOption < PVN::BooleanOption
+    def initialize optargs = Hash.new
+      opts = Hash.new
+      opts[:negate] = '--nomatch', '-M'
+      super :match, '-m', 'find where the pattern matched', true, opts
+    end
+  end
+
+  class OptionSet < PVN::Command::OptionSet
+    # has_option :revision, PVN::RevisionRegexpOption
+    # has_option :match,    MatchOption
+    has_option :help,     PVN::Command::HelpOption
+  end
+end

data/lib/pvn.rb

@@ -1,3 +1,3 @@
 module PVN
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/svnx/action.rb

@@ -5,40 +5,35 @@ require 'rubygems'
 require 'riel'
 
 module SVNx
-  # $$$ this cries for a little metaprogramming ... tomorrow
-
   class Action
-    include Loggable, Comparable    
+    include Loggable, Comparable
     
     attr_reader :type
 
-    def initialize str
-      @type = case str
-              when 'added', 'A', :added
-                :added
-              when 'deleted', 'D', :deleted
-                :deleted
-              when 'modified', 'M', :modified
-                :modified
-              when 'unversioned', '?', :unversioned
-                :unversioned
-              end
-    end
+    STATUS_TO_TYPE = Hash.new
 
-    def added?
-      @type == :added
+    def self.add_type sym, str, char
+      [ sym, str, char ].each do |key|
+        STATUS_TO_TYPE[key] = sym
+      end
     end
 
-    def deleted?
-      @type == :deleted
+    add_type :added, 'added', 'A'
+    add_type :deleted, 'deleted', 'D'
+    add_type :modified, 'modified', 'M'
+    add_type :unversioned, 'unversioned', '?'
+
+    STATUS_TO_TYPE.values.uniq.each do |val|
+      methname = val.to_s + '?'
+      define_method methname do
+        instance_eval do
+          @type == STATUS_TO_TYPE[val]
+        end
+      end
     end
     
-    def modified?
-      @type == :modified
-    end
-    
-    def unversioned?
-      @type == :unversioned
+    def initialize str
+      @type = STATUS_TO_TYPE[str]
     end
 
     def <=> other

data/test/integration/pvn/diff/changed_paths_test.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'riel'
+require 'pvn/diff/changed_paths'
+require 'integration/pvn/diff/tc'
+
+module PVN::Diff
+  class ChangedPathsTestCase < TestCase
+
+    def assert_diff paths, revision, whitespace, explines
+      orig_dir = Dir.pwd
+      Dir.chdir '/Programs/pvn/pvntestbed.pending'
+      strio = StringIO.new
+      $io = strio
+
+      cp = ChangedPaths.new paths
+      cp.diff_revision_to_working_copy revision, whitespace
+      
+      strio.close
+      puts strio.string
+      
+      actlines = strio.string.split "\n"
+
+      assert_arrays_equal explines, actlines
+
+      $io = $stdout
+      Dir.chdir orig_dir
+    end
+
+    def test_revision_against_working_copy
+      explines = Array.new
+
+      explines << "Index: FirstFile.txt"
+      explines << "==================================================================="
+      explines << "--- FirstFile.txt	(revision 22)"
+      explines << "+++ FirstFile.txt	(working copy)"
+      explines << "@@ -1,3 +1,4 @@"
+      explines << " this is the second line of the first file."
+      explines << "-third line here."
+      explines << "+    third line here."
+      explines << " fourth line this is."
+      explines << "+this is the fifth line."
+      explines << "Index: SecondFile.txt"
+      explines << "==================================================================="
+      explines << "--- SecondFile.txt	(revision 20)"
+      explines << "+++ SecondFile.txt	(working copy)"
+      explines << "@@ -1,4 +1,6 @@"
+      explines << " line one of file two."
+      explines << "+second line"
+      explines << "+third line"
+      explines << " line four"
+      explines << " line five"
+      explines << " line 6, Six, VI"
+      explines << "Index: SeventhFile.txt"
+      explines << "==================================================================="
+      explines << "--- SeventhFile.txt	(revision 0)"
+      explines << "+++ SeventhFile.txt	(revision 0)"
+      explines << "@@ -0,0 +1 @@"
+      explines << "+this is the 7th file."
+
+      ### $$$ this revision might not be zero in svn-land:
+      explines << "Index: archive/rubies.zip"
+      explines << "==================================================================="
+      explines << "Binary files archive/rubies.zip\t(revision 0) and archive/rubies.zip\t(revision working_copy) differ"
+
+      explines << "Index: dirzero/SixthFile.txt"
+      explines << "==================================================================="
+      explines << "--- dirzero/SixthFile.txt	(revision 22)"
+      explines << "+++ dirzero/SixthFile.txt	(working copy)"
+      explines << "@@ -1,2 +0,0 @@"
+      explines << "-line one."
+      explines << "-line two."
+      explines << "Index: src/ruby/charlie.rb"
+      explines << "==================================================================="
+      explines << "--- src/ruby/charlie.rb	(revision 20)"
+      explines << "+++ src/ruby/charlie.rb	(working copy)"
+      explines << "@@ -2,6 +2,7 @@"
+      explines << " # -*- ruby -*-"
+      explines << " "
+      explines << " def charlie x"
+      explines << "+  puts x"
+      explines << " end"
+      explines << " "
+      explines << " charlie 1"
+      explines << "Index: src/ruby/dog.rb"
+      explines << "==================================================================="
+      explines << "--- src/ruby/dog.rb	(revision 0)"
+      explines << "+++ src/ruby/dog.rb	(revision 0)"
+      explines << "@@ -0,0 +1,7 @@"
+      explines << "+#!/usr/bin/ruby -w"
+      explines << "+# -*- ruby -*-"
+      explines << "+"
+      explines << "+require 'rubygems'"
+      explines << "+require 'riel'"
+      explines << "+"
+      explines << "+puts \"hello, world\""
+      
+      # -r20 means -r20:working_copy
+
+      revision = PVN::Revision::Range.new 20, nil
+      whitespace = false
+      paths = %w{ . }
+
+      assert_diff paths, revision, whitespace, explines
+    end
+  end
+end

data/test/integration/pvn/diff/local_differ_test.rb

@@ -2,15 +2,15 @@
 # -*- ruby -*-
 
 require 'pvn/diff/local_differ'
-require 'integration/pvn/diff/differ_tc'
+require 'integration/pvn/diff/tc'
 
 Log.level = Log::DEBUG
 
 module PVN::Diff
-  class LocalDifferTestCase < DifferTestCase
+  class LocalDifferTestCase < TestCase
 
-    def create_differ opts
-      LocalDiffer.new opts
+    def assert_diff_command args, explines
+      super LocalDiffer, args, explines
     end
 
     def get_explines comparing_whitespace

data/test/integration/pvn/diff/log_paths_test.rb

@@ -7,11 +7,11 @@ require 'pvn/revision/range'
 
 module PVN::Diff
   class LogPathsTestCase < PVN::IntegrationTestCase
-    def assert_log_path exp_name, exp_nrevisions, expurl, logpaths, idx
+    def assert_log_path exp_name, exp_nchanges, expurl, logpaths, idx
       logpath = logpaths[idx]
       msg = "element[#{idx}]"
       assert_equal exp_name, logpath.name, msg
-      assert_equal exp_nrevisions, logpath.path_revisions.size, msg
+      assert_equal exp_nchanges, logpath.changes.size, msg
     end
       
     def test_revision_to_revision