pvn 0.0.5 → 0.0.6

data/lib/pvn/subcommands/diff/differ.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/subcommands/diff/options'
+require 'pvn/subcommands/base/command'
+require 'tempfile'
+
+$io = $stdout
+
+module PVN::Subcommands::Diff
+  class Differ
+    include Loggable
+
+    attr_reader :whitespace
+    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
+        info "topath: #{topath}"
+        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 entry, fromrev, torev, frompath, topath
+      info "whitespace: #{whitespace}"
+      
+      cmd = "diff -u"
+      if whitespace
+        cmd << " -x -b -x -w -x --ignore-eol-style"
+      end
+
+      [ fromrev, torev ].each do |rev|
+        revstr = to_revision_string rev
+        cmd << " -L '#{entry.path}\t(#{revstr})'"
+      end
+      cmd << " #{frompath}"
+      cmd << " #{topath}"
+      $io.puts "Index: #{entry.path}"
+      $io.puts "==================================================================="
+      IO.popen(cmd) do |io|
+        $io.puts io.readlines
+      end
+    end
+  end
+end

data/lib/pvn/subcommands/diff/local_differ.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/subcommands/diff/options'
+require 'tempfile'
+require 'pvn/subcommands/diff/differ'
+
+module PVN::Subcommands::Diff
+  class LocalDiffer < Differ
+    def initialize options
+      super
+      
+      paths = options.paths
+      paths = %w{ . } if paths.empty?
+
+      info "paths: #{paths}".yellow
+
+      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|
+        info "path: #{path}".red
+        elmt = PVN::IO::Element.new :local => path
+        entries = elmt.find_files_by_status
+        
+        allentries.concat entries.sort_by { |n| n.path }
+      end
+
+      info "allentries: #{allentries}"
+
+      allentries.each do |entry|
+        info "entry: #{entry.inspect}".on_blue
+        case entry.status
+        when 'modified'
+          show_as_modified entry
+        when 'deleted'
+          show_as_deleted entry
+        when 'added'
+          show_as_added entry
+        end
+      end
+    end
+
+    def read_working_copy entry
+      pn = Pathname.new entry.path
+      pn.readlines
+    end
+
+    def show_as_added entry
+      Tempfile.open('pvn') do |from|
+        # from is an empty file
+        from.close
+
+        # I think this is always revision 0
+        run_diff_command entry, 0, 0, from.path, entry.path
+      end
+    end
+
+    def show_as_deleted entry
+      elmt = PVN::IO::Element.new :local => entry.path
+
+      svninfo = elmt.get_info
+      lines = elmt.cat_remote
+
+      Tempfile.open('pvn') do |from|
+        from.puts lines
+        from.close
+        Tempfile.open('pvn') do |to|
+          # to is an empty file
+          to.close
+          run_diff_command entry, svninfo.revision, nil, from.path, to.path
+        end
+      end
+    end
+    
+    def show_as_modified entry
+      # only doing working copy to remote now      
+      elmt = PVN::IO::Element.new :local => entry.path
+
+      svninfo = elmt.get_info
+      remotelines = elmt.cat_remote
+
+      fromrev = svninfo.revision
+      torev = nil               # AKA working copy
+
+      wclines = read_working_copy entry
+
+      Tempfile.open('pvn') do |from|
+        from.puts remotelines
+        from.close
+        Tempfile.open('pvn') do |to|
+          to.puts wclines
+          to.close
+          run_diff_command entry, fromrev, torev, from.path, to.path
+        end
+      end
+    end
+  end
+end

data/lib/pvn/subcommands/diff/options.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'synoption/boolean_option'
+require 'pvn/subcommands/revision/multiple_revisions_option'
+require 'pvn/subcommands/revision/base_option'
+require 'pvn/subcommands/base/options'
+
+module PVN::Subcommands::Diff
+  class WhitespaceOption < PVN::BooleanOption
+    def initialize optargs = Hash.new
+      super :whitespace, '-w', 'ignore all whitespace', false
+    end
+  end
+
+  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
+    has_option :revision,   PVN::MultipleRevisionsRegexpOption
+    has_option :change,     ChangeOption
+    has_option :whitespace, WhitespaceOption
+    has_option :help,       PVN::Subcommands::Base::HelpOption
+  end
+end

data/lib/pvn/subcommands/diff/repository_differ.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/io/element'
+require 'pvn/subcommands/diff/options'
+require 'tempfile'
+require 'pvn/subcommands/diff/differ'
+
+module PVN::Subcommands::Diff
+  # this will replace RevisionEntry
+  class Revision
+    include Loggable
+    
+    attr_reader :value
+    attr_reader :from
+    attr_reader :to
+
+    def initialize from, to = nil
+      if to
+        @from = from
+        @to = to
+      else
+        @from, @to = from.split(':')
+      end
+      info "@from: #{@from}"
+      info "@to: #{@to}"
+    end
+
+    def to_s
+      str = @from.to_s
+      if @to
+        str << ':' << @to.to_s
+      end
+      str
+    end
+
+    def head?
+      @to == nil
+    end
+  end
+
+  class RepositoryDiffer < Differ
+    include Loggable
+
+    attr_reader :whitespace
+    attr_reader :revision
+    
+    def initialize options
+      paths = options.paths
+      paths = %w{ . } if paths.empty?
+
+      info "paths: #{paths}"
+
+      allentries = Array.new
+
+      # 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
+      info "change: #{change}"
+      info "rev: #{rev}"
+      info "rev: #{rev.class}"
+
+      if change
+        @revision = Revision.new(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.
+
+          ### $$$ this doesn't handle dates:
+          @revision = Revision.new(rev[0].to_i + 1, rev[0].to_i)
+        else
+          from, to = rev[0].split(':')
+          @revision = Revision.new(from.to_i + 1, to)
+        end
+      end
+
+      info "revision: #{@revision}; #{@revision.class}".on_blue
+
+      # maps from pathnames to { :first, :last } revision updated.
+      paths_to_revisions = Hash.new
+
+      paths.each do |path|
+        logentries = get_log_entries path, @revision
+        logentries.each do |logentry|
+          info "logentry: #{logentry}".yellow
+          info "logentry.revision: #{logentry.revision}".yellow
+          info "logentry.paths: #{logentry.paths}".yellow
+
+          # should add the revision to this, so we know which is the first
+          # version to compare against the last:
+
+          logentry.paths.each do |lp|
+            info "lp: #{lp.inspect}".cyan
+            allentries << { :path => lp, :revision => logentry.revision }
+            rec = paths_to_revisions[lp.name]
+            if rec
+              rec[:last] = logentry.revision
+            else
+              rec = { :first => logentry.revision, :action => lp.action }
+            end
+            paths_to_revisions[lp.name] = rec
+          end 
+        end
+      end
+
+      paths_to_revisions.sort.each do |name, revisions|
+        puts "name: #{name}"
+        puts "revisions: #{revisions}"
+      end
+
+      info "allentries: #{allentries}"
+
+      allentries.each do |entry|
+        info "entry: #{entry.inspect}".on_blue
+        next if true
+        case entry.status
+        when 'modified'
+          show_as_modified entry
+        when 'deleted'
+          show_as_deleted entry
+        when 'added'
+          show_as_added entry
+        end
+      end
+    end
+
+    def get_log_entries path, revision
+      cmdargs = Hash.new
+      cmdargs[:path] = path
+      cmdargs[:revision] = revision.to_s
+      cmdargs[:verbose] = true
+
+      # should be conditional on revision:
+      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/subcommands/log/command.rb

@@ -31,10 +31,33 @@ module PVN::Subcommands::Log
     example "pvn log -r 122 -v",        "Prints log entry for revision 122, with the files in that change."
     example "pvn log -u barney",        "Prints log entries only for user 'barney', with the default limit."
     
-    def initialize options = nil
-      return unless options
+    def init options
+      paths = options.paths
 
-      path = options.paths[0] || "."
+      paths = %w{ . } if paths.empty?
+
+      info "paths: #{paths}"
+
+      allentries = Array.new
+
+      paths.each do |path|
+        allentries.concat find_entries_for_path path, options
+      end
+
+      # we can show relative revisions for a single path, without filtering by
+      # user, or by limit or revision.
+
+      show_relative = !options.user && paths.size == 1 && !options.revision
+      
+      # this should be refined to options.revision.head?
+      from_head = show_relative
+      from_tail = show_relative && !options.limit
+
+      ef = PVN::Log::EntriesFormatter.new options.color, allentries, from_head, from_tail
+      puts ef.format
+    end
+
+    def find_entries_for_path path, options
       cmdargs = Hash.new
       cmdargs[:path] = path
       
@@ -55,10 +78,6 @@ module PVN::Subcommands::Log
       log     = elmt.log logargs
       entries = log.entries
 
-      # this should be refined to options.revision.head?
-      from_head = !options.revision
-      from_tail = !options.limit && !options.revision
-
       info { "options: #{options}" }
       info { "options.user: #{options.user}" }
 
@@ -69,10 +88,9 @@ module PVN::Subcommands::Log
         # don't show relative revisions, since we've got a slice out of the list:
         from_head = nil
         from_tail = nil
-      end        
-      
-      ef = PVN::Log::EntriesFormatter.new options.color, entries, from_head, from_tail
-      puts ef.format
+      end
+
+      entries
     end
 
     def find_entries_for_user entries, user, limit

data/lib/pvn/subcommands/log/options.rb

@@ -37,9 +37,5 @@ module PVN::Subcommands::Log
     has_option :limit,    LimitOption
     has_option :user,     UserOption
     has_option :verbose,  PVN::BooleanOption, [ :verbose, '-v', [ "include the files in the change" ], false ]
-    
-    def paths
-      unprocessed
-    end
   end
 end

data/lib/pvn/subcommands/pct/command.rb

@@ -1,20 +1,14 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'pvn/io/element'
 require 'pvn/subcommands/pct/options'
 require 'pvn/subcommands/base/command'
-require 'svnx/info/command'
-require 'svnx/status/command'
-require 'svnx/cat/command'
-require 'pvn/subcommands/pct/diffcount'
-require 'set'
+require 'pvn/subcommands/pct/local_differ'
+require 'pvn/subcommands/pct/repository_differ'
 
 module PVN::Subcommands::Pct
   class Command < PVN::Subcommands::Base::Command
 
-    DEFAULT_LIMIT = 15
-
     subcommands [ "pct" ]
     description "Compares revisions as a percentage of lines modified."
     usage       "[OPTIONS] FILE..."
@@ -33,177 +27,17 @@ module PVN::Subcommands::Pct
     optscls
 
     example "pvn pct foo.rb",       "Prints the changes in foo.rb, working copy against BASE."
-    example "pvn pct -r114:121",    "Prints the changes for all files, revision 114 against 121. (not yet supported)"
+    example "pvn pct -r114:121",    "Prints the changes for all files, revision 114 against 121."
     example "pvn pct -rHEAD",       "Prints the changes, working copy against HEAD. (not yet supported)"
-    example "pvn pct -r117",        "Prints the changes between revision 117 and the previous revision. (not yet supported)"
-    example "pvn pct -7",           "Prints the changes between relative revision -7 and the previous revision. (not yet supported)"
-    example "pvn pct -r31 -4",      "Prints the changes between revision 31 and relative revision -4. (not yet supported)"
-
-    class << self
-      # base command aliases new to init, so we're aliasing init to init2
-      alias_method :init2, :init
-
-      def init options
-        if options.revision && !options.revision.empty?
-          CommandRepository.init2 options
-        else
-          CommandLocal.init2 options
-        end
-      end
-    end
-
-    def initialize options = nil
-    end
-  end
-
-  class CommandLocal < Command
-    def initialize options
-      # do we support multiple paths?
-      path = options.paths[0] || '.'
-
-      elmt = PVN::IO::Element.new :local => path || '.'
-      modified = elmt.find_modified_files
-      info "modified: #{modified}".blue
-
-      total = PVN::DiffCount.new
-
-      modified = modified.sort_by { |n| n.path }
-
-      modified.each do |entry|
-        catcmd = SVNx::CatCommand.new entry.path
-        info "catcmd: #{catcmd}"
-          
-        svn_count = catcmd.execute.size
-        info "svn_count: #{svn_count}"
-        
-        local_count = Pathname.new(entry.path).readlines.size
-        info "local_count: #{local_count}"
+    example "pvn pct -r117",        "Prints the changes between revision 117 and the previous revision."
+    example "pvn pct -7",           "Prints the changes between relative revision -7 and the previous revision."
+    example "pvn pct -r31 -4",      "Prints the changes between revision 31 and relative revision -4."
 
-        dc = PVN::DiffCount.new svn_count, local_count
-        total << dc
-        dc.print entry.path
-      end
-
-      total.print 'total'
-    end
-  end
-
-  class CommandRepository < Command
-    ### $$$ 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
-        else
-          return [ rev[0], rev[1] ]
-        end
+    def init options
+      if options.revision && !options.revision.empty?
+        RepositoryDiffer.new options
       else
-        info "rev: #{rev}".bold.white.on_red
-      end
-    end
-
-    def get_line_count path, revision
-      cmdargs = SVNx::CatCommandArgs.new :path => path, :revision => revision
-      catcmd = SVNx::CatCommand.new cmdargs
-      catcmd.execute.size
-    end
-    
-    def initialize options
-      # what was modified between the revisions?
-
-      path = options.paths[0] || "."
-      info "path: #{path}"
-
-      elmt = PVN::IO::Element.new :local => path || '.'
-      modified = elmt.find_modified_entries options.revision
-
-      modnames = modified.collect { |m| m.name }.sort.uniq
-
-      fromrev, torev = get_from_to_revisions options.revision
-
-      total = PVN::DiffCount.new
-
-      reporoot = elmt.repo_root
-
-      direlmt = PVN::IO::Element.new :local => '.'
-      svninfo = direlmt.get_info
-
-      filter = svninfo.url.dup
-      filter.slice! svninfo.root
-      info "filter: #{filter}"
-      filterre = Regexp.new '^' + filter + '/'
-      
-      modnames.each do |mod|
-        fullpath = reporoot + mod
-        elmt = PVN::IO::Element.new :path => fullpath
-
-        next unless elmt.has_revision? fromrev
-        next unless elmt.has_revision? torev
-        next if elmt.get_info.kind == 'dir'
-
-        from_count = get_line_count fullpath, fromrev
-        to_count = get_line_count fullpath, torev
-
-        dc = PVN::DiffCount.new from_count, to_count
-        total << dc
-        mod.slice! filterre
-        dc.print mod
-      end
-
-      total.print 'total'
-    end
-
-
-  end
-
-end
-
-__END__
-
-      elmt = PVN::IO::Element.new :local => clargs.path || '.'
-      info "elmt: #{elmt}".red
-
-      stats = { :modified => 0, :added => 0, :deleted => 0 }
-
-      if elmt.directory?
-        info "elmt.directory?: #{elmt.directory?}"
-
-        # $$$ todo: recurse even when local has been removed (this is the
-        # awaited "pvn find").
-        
-        changed = Array.new
-        elmt.local.find do |fd|
-          info "fd: #{fd}; #{fd.class}"
-          Find.prune if fd.rootname.to_s == '.svn'
-          if fd.file?
-            subelmt = PVN::IO::Element.new :local => fd.to_s
-            info "subelmt: #{subelmt}"
-            status = subelmt.status
-            info "status: #{status}".red
-          end
-        end
-
-        # info "changed: #{changed}"
-      elsif elmt.file?
-        info "elmt.local: #{elmt.local}".cyan
-
-        status = elmt.status
-        info "status: #{status}"
-
-        case status
-        when "added"
-          info "elmt: #{elmt}".green
-        when "modified"
-          info "elmt: #{elmt}".yellow
-        when "deleted"
-          info "elmt: #{elmt}".red
-        else
-          info "elmt: #{elmt}".cyan
-        end
+        LocalDiffer.new options
       end
     end
   end

data/lib/pvn/subcommands/pct/diffcount.rb

@@ -5,13 +5,15 @@ module PVN
   class DiffCount
     attr_reader :from
     attr_reader :to
+    attr_reader :name
 
-    def initialize from = 0, to = 0
+    def initialize from = 0, to = 0, name = nil
       @from = from
       @to = to
+      @name = name
     end
 
-    def print name
+    def print name = @name
       diff = to - from
       diffpct = diff == 0 ? 0 : 100.0 * diff / from
       

data/lib/pvn/subcommands/pct/differ.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pvn/subcommands/pct/diffcount'
+
+module PVN::Subcommands::Pct
+  class Differ
+    include Loggable
+
+    def initialize options
+      show_diff_counts options
+    end
+
+    def show_diff_counts options
+      paths = options.paths
+      paths = %w{ . } if paths.empty?
+
+      info "paths: #{paths}"
+
+      total = PVN::DiffCount.new 0, 0, 'total'
+
+      paths.each do |path|
+        diff_counts = get_diff_counts path, options
+        
+        diff_counts.each do |dc|
+          total << dc
+          dc.print
+        end
+      end
+
+      total.print
+    end
+  end
+end