pvn 0.0.7 → 0.0.8

data/lib/pvn/{subcommands/diff → diff}/command.rb

@@ -2,15 +2,15 @@
 # -*- ruby -*-
 
 require 'pvn/io/element'
-require 'pvn/subcommands/diff/options'
-require 'pvn/subcommands/base/command'
-require 'pvn/subcommands/diff/local_differ'
-require 'pvn/subcommands/diff/repository_differ'
+require 'pvn/diff/options'
+require 'pvn/command/command'
+require 'pvn/diff/local_differ'
+require 'pvn/diff/repository_differ'
 require 'tempfile'
 require 'synoption/exception'
 
-module PVN::Subcommands::Diff
-  class Command < PVN::Subcommands::Base::Command
+module PVN::Diff
+  class Command < PVN::Command::Command
 
     subcommands [ "diff" ]
     description "Shows the changes to files."

data/lib/pvn/diff/differ.rb

@@ -1,67 +1,83 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'pathname'
-require 'pvn/config'
+require 'pvn/io/element'
+require 'pvn/diff/options'
+require 'pvn/command/command'
+require 'tempfile'
 
-module PVN
-  # the app for svn --diff-cmd
+$io = $stdout
+
+module PVN::Diff
   class Differ
     include Loggable
-    
-    def initialize args
-      fromlabel = args[2]
-      tolabel = args[4]
-
-      fromname, fromrev = fromlabel.split("\t")
-      toname, torev = tolabel.split("\t")
 
-      fromfile = args[-2]
-      tofile = args[-1]
-
-      diffcmd = diff_command_by_ext fromname
-      info "diffcmd: #{diffcmd}"
+    attr_reader :whitespace
+    attr_reader :revision
+    
+    def initialize options
+    end
 
-      if diffcmd
-        workingcmd = diffcmd.dup
+    def to_revision_string rev
+      rev ? "revision #{rev}" : "working copy"
+    end
 
-        [ fromlabel, tolabel, fromfile, tofile ].each_with_index do |str, idx|
-          workingcmd.gsub! Regexp.new('\{' + idx.to_s + '\}'), str
+    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
-
-        run_command workingcmd
-      else
-        run_diff_default fromlabel, tolabel, fromfile, tofile
       end
     end
 
-    def diff_command_by_ext fname
-      extname = Pathname.new(fname).extname
-      return nil if extname.empty?
-
-      ext = extname[1 .. -1]
+    def run_diff_command displaypath, fromrev, torev, frompath, topath
+      cmd = "diff -u"
+      if whitespace
+        cmd << " -w"
+      end
 
-      cfg = PVN::Configuration.read
+      [ fromrev, torev ].each do |rev|
+        revstr = to_revision_string rev
+        cmd << " -L '#{displaypath}\t(#{revstr})'"
+      end
+      cmd << " #{frompath}"
+      cmd << " #{topath}"
 
-      diffcfg = cfg.section "diff"
-      return nil unless diffcfg
+      info "cmd: #{cmd}"
 
-      diff_for_ext = diffcfg.assoc(ext)
-      diff_for_ext && diff_for_ext[1]
+      $io.puts "Index: #{displaypath}"
+      $io.puts "==================================================================="
+      IO.popen(cmd) do |io|
+        $io.puts io.readlines
+      end
     end
 
-    def run_diff_default fromfname, tofname, fromfile, tofile
-      cmd = "diff -u --label \"#{fromfname}\" --label \"#{tofname}\" #{fromfile} #{tofile}"
-      run_command cmd
-    end
+    def run_diff displaypath, fromlines, fromrev, tolines, torev
+      Tempfile.open('pvn') do |from|
+        if fromlines
+          from.puts fromlines
+        end
+        from.close
 
-    def run_command cmd
-      info "cmd: #{cmd}".red
-      IO.popen(cmd) do |io|
-        io.each do |line|
-          puts line
+        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        
+      end
     end
   end
 end

data/lib/pvn/diff/local_differ.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/diff/options'
+require 'pvn/diff/differ'
+
+module PVN::Diff
+  class LocalDiffer < Differ
+    def initialize options
+      super
+      
+      paths = options.paths
+      paths = %w{ . } if paths.empty?
+
+      allentries = Array.new
+
+      # 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
+      end
+    end
+
+    ### $$$ todo: integrate these, from old diff/diffcmd
+    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/log_paths.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/diff/paths'
+require 'pvn/diff/path'
+
+module PVN::Diff
+  # represents the log entries from one revision through another.
+  class LogPaths < Paths
+    include Loggable
+
+    def add_for_path path
+      pathelmt = PVN::IO::Element.new :local => path
+      pathinfo = pathelmt.get_info
+      elmt = PVN::IO::Element.new :local => path
+      logentries = elmt.logentries @revision
+
+      logentries.each do |logentry|
+        logentry.paths.each do |logentrypath|
+          next if logentrypath.kind != 'file'
+          add_path logentry, logentrypath, pathinfo
+        end 
+      end
+    end
+
+    def add_path logentry, logentrypath, pathinfo
+      name = logentrypath.name
+      revision = logentry.revision
+      action = logentrypath.action
+      url = pathinfo.url
+
+      info "action: #{action}".blue
+      
+      path = @elements.detect { |element| element.name == name }
+      if path
+        info "path: #{path}".on_blue
+        path.add_revision logentry.revision, action
+      else
+        path = Path.new(name, logentry.revision, action, url)
+        info "path: #{path}".on_cyan
+        @elements << path
+      end
+    end
+  end
+end

data/lib/pvn/{subcommands/diff → diff}/options.rb

@@ -2,27 +2,29 @@
 # -*- ruby -*-
 
 require 'synoption/boolean_option'
-require 'pvn/subcommands/revision/multiple_revisions_option'
-require 'pvn/subcommands/revision/base_option'
-require 'pvn/subcommands/base/options'
+require 'pvn/revision/multiple_revisions_option'
+require 'pvn/revision/base_option'
+require 'pvn/command/options'
 
-module PVN::Subcommands::Diff
+module PVN::Diff
   class WhitespaceOption < PVN::BooleanOption
     def initialize optargs = Hash.new
       super :whitespace, '-w', 'ignore all whitespace', false
     end
   end
 
+  # a change option is like a revision option, just against the previous
+  # revision
   class ChangeOption < PVN::BaseRevisionOption
     def initialize optargs = Hash.new
       super :change, '-c', 'use the given revision against the previous one', nil
     end
   end
 
-  class OptionSet < PVN::Subcommands::Base::OptionSet
+  class OptionSet < PVN::Command::OptionSet
     has_option :revision,   PVN::MultipleRevisionsRegexpOption
     has_option :change,     ChangeOption
     has_option :whitespace, WhitespaceOption
-    has_option :help,       PVN::Subcommands::Base::HelpOption
+    has_option :help,       PVN::Command::HelpOption
   end
 end

data/lib/pvn/diff/path.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/action'
+require 'pvn/diff/path_revision'
+
+module PVN; module Diff; end; end
+
+module PVN::Diff
+  class Path
+    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
+    
+    # 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)
+      @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)
+    end
+
+    def to_revision rev
+      # or should we convert this to Revision::Argument, and @revisions is
+      # Revision::Range?
+      rev.kind_of?(Fixnum) ? rev.to_s : rev
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/pvn/diff/path_revision.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/action'
+
+module PVN; module Diff; end; end
+
+# A Path Revision is the change to a path within a changelist. 
+module PVN::Diff
+  class PathRevision
+    include Loggable
+    
+    attr_reader :revision
+    attr_reader :action
+    
+    def initialize revision, action
+      @revision = to_revision(revision)
+      @action = action.kind_of?(SVNx::Action) || SVNx::Action.new(action)
+    end
+
+    def to_revision rev
+      # or should we convert this to Revision::Argument, and @revisions is
+      # Revision::Range?
+      rev.kind_of?(Fixnum) ? rev.to_s : rev
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/pvn/diff/paths.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module PVN::Diff
+  # represents the paths from one revision through another.
+  class Paths
+    include Loggable, Enumerable
+
+    # takes paths of the form ".", "foo.rb", etc.
+    def initialize revision, paths
+      @revision = revision
+      @elements = Array.new
+      
+      paths.each do |path|
+        add_for_path path
+      end
+    end
+
+    def add_for_path path
+      raise "implement this"
+    end
+
+    def [] idx
+      @elements[idx]
+    end
+
+    def size
+      @elements.size
+    end
+
+    # returns a map from names to logpaths
+    def to_map
+      names_to_paths = Hash.new
+      @elements.each { |path| names_to_paths[path.name] = path }
+      names_to_paths
+    end
+
+    def each(&blk)
+      @elements.each(&blk)
+    end
+  end
+end

data/lib/pvn/diff/repository_differ.rb

@@ -0,0 +1,154 @@
+#!/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'
+
+module PVN::Diff
+  class RepositoryDiffer < Differ
+    include Loggable
+
+    attr_reader :whitespace
+    attr_reader :revision
+    
+    def initialize options
+      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
+
+      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
+
+      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
+      end
+    end
+  end
+end

data/lib/pvn/diff/revision.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/revision/range'
+
+module PVN::Diff
+  class RevisionRange < PVN::Revision::Range
+    include Loggable, Comparable
+
+    def initialize change, rev
+      if change
+        super change.to_i - 1, change.to_i
+      elsif rev.kind_of? Array
+        if rev.size == 2
+          # this is some contorting, since -rx:y does not mean comparing the files
+          # in changelist x; it means all the entries from x+1 through y, inclusive.
+
+          super rev[0].to_i, rev[1].to_i
+        else
+          from, to = rev[0].split(':')
+          info "from: #{from}"
+          info "to  : #{to}".cyan
+          super from, to
+        end
+      else
+        raise "revision argument not handled: #{rev}"
+      end
+    end
+
+    def <=> other
+      info "other: #{other}".yellow
+      info "self: #{self}".yellow
+      nil
+    end
+  end
+end