pvn 0.0.11 → 0.1.1

data/lib/pvn/diff/log_path.rb

@@ -8,20 +8,25 @@ 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
+    # These are in the process of being refactored.
+    def show_as_modified elmt, path, changes, revision, whitespace
+      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
+
+      fromlines = elmt.cat firstrev
       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
 
@@ -37,26 +42,18 @@ module PVN::Diff
     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
@@ -69,26 +66,17 @@ module PVN::Diff
       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
+        show_as_modified elmt, displaypath, changes, 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
+        change.revision.to_i
       elsif change.revision.to_i >= revision.from.value
-        return revision.from.value
+        revision.from.value
       else
         nil
       end
@@ -101,31 +89,34 @@ module PVN::Diff
       ### modified.
 
       change = revisions_later_than(fromrev).first
-      info "change: #{change}".red
+      info "change: #{change}".color(:red)
 
       # revision should be a class here, not a primitive
       diffrev = get_diff_revision change, revision
       
-      display_path = get_display_path
+      displaypath = get_display_path
 
-      pn = Pathname.new display_path
+      pn = Pathname.new displaypath
 
+      info "url: #{url}"
+      info "name: #{name}"
       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
+        show_as_added elmt, displaypath, revision, whitespace
       else
         fromlines = elmt.cat diffrev
         info "fromlines.size: #{fromlines.size}"
-        pp fromlines
+        # pp fromlines
 
         tolines = pn.readlines
         info "tolines.size: #{tolines.size}"
-        pp tolines
+        # pp tolines
 
-        run_diff display_path, fromlines, diffrev, tolines, nil, whitespace
+        run_diff displaypath, fromlines, diffrev, tolines, nil, whitespace
       end
     end
 
@@ -135,7 +126,6 @@ module PVN::Diff
 
     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

data/lib/pvn/diff/log_paths.rb

@@ -4,11 +4,12 @@
 require 'pvn/io/element'
 require 'pvn/diff/paths'
 require 'pvn/diff/log_path'
+require 'logue/loggable'
 
 module PVN::Diff
   # represents the log entries from one revision through another.
   class LogPaths < Paths
-    include Loggable
+    include Logue::Loggable
 
     def add_for_path path
       pathelmt = PVN::IO::Element.new :local => path
@@ -31,13 +32,14 @@ module PVN::Diff
       url = pathinfo.url
 
       info "action: #{action}"
+      info "url: #{url}"
       
       path = @elements.detect { |element| element.name == name }
       if path
         info "path: #{path}"
-        path.add_change logentry.revision, action
+        path.add_change revision, action
       else
-        path = LogPath.new(name, logentry.revision, action, url)
+        path = LogPath.new(name, revision, action, url)
         info "path: #{path}"
         @elements << path
       end

data/lib/pvn/diff/options.rb

@@ -7,7 +7,7 @@ require 'pvn/revision/base_option'
 require 'pvn/command/options'
 
 module PVN::Diff
-  class WhitespaceOption < PVN::BooleanOption
+  class WhitespaceOption < Synoption::BooleanOption
     def initialize optargs = Hash.new
       super :whitespace, '-w', 'ignore all whitespace', false
     end

data/lib/pvn/diff/path.rb

@@ -1,14 +1,14 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'svnx/action'
+require 'logue/loggable'
+require 'riel/pathname'
 require 'pvn/diff/change'
-
-module PVN; module Diff; end; end
+require 'pvn/diff/diffset'
 
 module PVN::Diff
   class Path
-    include Loggable
+    include Logue::Loggable
     
     attr_reader :name
     attr_reader :url
@@ -21,9 +21,8 @@ module PVN::Diff
       add_change revision, action
       @url = url
     end
-
+    
     def add_change rev, action
-      info "rev: #{rev}"
       @changes << Change.new(to_revision(rev), action)
     end
 
@@ -33,52 +32,17 @@ module PVN::Diff
       rev.kind_of?(Fixnum) ? rev.to_s : rev
     end
 
-    def to_s
-      inspect
-    end
-    
-    def to_revision_string rev
-      rev ? "revision #{rev}" : "working copy"
+    def run_diff displaypath, fromlines, fromrev, tolines, torev, whitespace
+      ds = DiffSet.new displaypath, fromlines, fromrev, tolines, torev, whitespace
+      ds.run_diff
     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
+    def to_s
+      "#{name}; #{url}"
     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
+    def <=> other
+      name <=> other.name
     end
   end
 end

data/lib/pvn/diff/paths.rb

@@ -1,15 +1,18 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
+require 'logue/loggable'
+require 'set'
+
 module PVN::Diff
   # represents the paths from one revision through another.
   class Paths
-    include Loggable, Enumerable
+    include Logue::Loggable, Enumerable
 
     # takes paths of the form ".", "foo.rb", etc.
     def initialize revision, paths
       @revision = revision
-      @elements = Array.new
+      @elements = SortedSet.new
       
       paths.each do |path|
         add_for_path path
@@ -21,7 +24,7 @@ module PVN::Diff
     end
 
     def [] idx
-      @elements[idx]
+      @elements.to_a[idx]
     end
 
     def size

data/lib/pvn/diff/repository_differ.rb

@@ -6,10 +6,11 @@ require 'pvn/diff/differ'
 require 'pvn/diff/log_paths'
 require 'pvn/diff/status_paths'
 require 'pvn/diff/changed_paths'
+require 'logue/loggable'
 
 module PVN::Diff
   class RepositoryDiffer < Differ
-    include Loggable
+    include Logue::Loggable
 
     attr_reader :whitespace
     attr_reader :revision
@@ -20,6 +21,8 @@ module PVN::Diff
       paths = options.paths
       paths = %w{ . } if paths.empty?
 
+      info "paths: #{paths}"
+
       # we sort only the sub-entries, so the order in which paths were specified is preserved
 
       rev = options.revision

data/lib/pvn/diff/status_paths.rb

@@ -4,10 +4,12 @@
 require 'pvn/io/element'
 require 'pvn/diff/path'
 require 'pvn/diff/paths'
+require 'logue/loggable'
+require 'pvn/diff/local_path'
 
 module PVN::Diff
   class StatusPaths < Paths
-    include Loggable
+    include Logue::Loggable
 
     def add_for_path path
       pathelmt = PVN::IO::Element.new :local => path
@@ -23,12 +25,13 @@ module PVN::Diff
         next if entry.status == 'unversioned'
         
         # svn log prepends /; svn status does not
-        name = '/' + entry.path
-        rev = :working_copy
+        # name = '/' + entry.path
+        # rev = :working_copy
 
         # what Status::Entry calls a status, we call an action, unifying it with
         # svn log representation.
-        action = entry.status
+        # action = entry.status
+
         info "entry.status_revision: #{entry.status_revision}"
         path = LocalPath.new entry
         @elements << path

data/lib/pvn/doc.rb

@@ -2,14 +2,12 @@
 # -*- ruby -*-
 
 require 'rubygems'
-require 'riel'
+require 'logue/loggable'
 require 'pvn/documenter'
 
-# Log.level = Log::DEBUG
-
 module PVN
   module Doc
-    include Loggable
+    include Logue::Loggable
 
     def self.included base
       base.extend ClassMethods

data/lib/pvn/io/element.rb

@@ -2,20 +2,12 @@
 # -*- ruby -*-
 
 require 'rubygems'
-require 'riel'
-
-require 'svnx/log/command'
+require 'logue/loggable'
 require 'svnx/log/entries'
-
-require 'svnx/status/command'
 require 'svnx/status/entries'
-
-require 'svnx/info/command'
 require 'svnx/info/entries'
-
-require 'svnx/cat/command'
-
 require 'pvn/io/fselement'
+require 'svnx/exec'
 
 module PVN; module IO; end; end
 
@@ -24,23 +16,23 @@ module PVN::IO
   # which should exist).
 
   class Element
-    include Loggable
+    include Logue::Loggable
 
     attr_reader :svn
     attr_reader :local
     
     def initialize args = Hash.new
-      info "args: #{args}"
+      info "args: #{args.inspect}".color("438802")
       
-      svnurl = args[:svnurl]
-      fname  = args[:filename] || args[:file] # legacy
+      # svnurl = args[:svnurl]
+      # fname  = args[:filename] || args[:file] # legacy
       # $$$ todo: map svnurl to SVNElement, and fname to FSElement
 
       @svn   = args[:svn] || (args[:file] && SVNElement.new(:filename => args[:file]))
       @local = args[:local] && PVN::FSElement.new(args[:local] || args[:file])
       @path  = args[:path]
       
-      info "local: #{@local}"
+      info "local: #{@local.inspect}"
     end
 
     def exist?
@@ -66,9 +58,7 @@ module PVN::IO
 
     def get_info revision = nil
       usepath = @local || @path
-      cmdargs = SVNx::InfoCommandArgs.new :path => usepath, :revision => revision
-      infcmd  = SVNx::InfoCommand.new cmdargs
-      output  = infcmd.execute
+      output = SVNx::Exec.new.info usepath, revision
       
       infentries = SVNx::Info::Entries.new :xmllines => output
       infentries[0]
@@ -81,35 +71,27 @@ module PVN::IO
     def has_revision? rev
       # was there a revision then?
       begin
-        svninfo = get_info rev
+        get_info rev
         true
       rescue => e
-        # skip it
-        false
+        puts "e: #{e}"
+        raise e
+        # false
       end
     end
 
     # returns a set of entries modified over the given revision
     def find_modified_entries revision
-      cmdargs = Hash.new
-
       svninfo = get_info
 
       filter = svninfo.url.dup
       filter.slice! svninfo.root
 
-      cmdargs[:path] = @local
-      
       # we can't cache this, because we don't know if there has been an svn
       # update since the previous run:
-      cmdargs[:use_cache] = false
-      cmdargs[:limit] = nil
-      cmdargs[:verbose] = true
-      cmdargs[:revision] = revision
-
-      logargs = SVNx::LogCommandArgs.new cmdargs
-      entries = log(logargs).entries
-
+      xmllines = SVNx::Exec.new.log @local, revision, nil, true, false
+      entries = SVNx::Log::Entries.new :xmllines => xmllines
+      
       modified = Set.new
 
       entries.each do |entry|
@@ -123,43 +105,27 @@ module PVN::IO
       modified
     end
 
-    def xxxcat_remote rev = nil
-      path = @local || @svn
-      info "path: #{path}".blue
-      info "rev: #{rev}; #{rev.class}".blue
-      catargs = SVNx::CatCommandArgs.new :path => path, :use_cache => false, :revision => rev
-      cmd = SVNx::CatCommand.new catargs
-      cmd.execute
-    end
-
     def cat revision, use_cache = false
+      info "@local: #{@local}"
+      info "@path: #{@path}"
+      info "@svn: #{@svn}"
+      
       path = (@local || @path || @svn).dup
+      info "path: #{path.to_s}"
       if revision && revision != :working_copy
         path << '@' << revision.to_s
       end
       info "path: #{path}"
-      catargs = SVNx::CatCommandArgs.new :path => path, :use_cache => use_cache
-      cmd = SVNx::CatCommand.new catargs
-      cmd.execute
-    end
-
-    # returns a set of local files that are in the given status
-    def find_files
+      SVNx::Exec.new.cat path, nil, use_cache
     end
 
     # returns a set of local files that are in the given status
     def find_files_by_status status = nil
-      cmdargs = SVNx::StatusCommandArgs.new :path => @local, :use_cache => false
-      cmd = SVNx::StatusCommand.new cmdargs
-      xmllines = cmd.execute
+      xmllines = SVNx::Exec.new.status @local, false
       entries = SVNx::Status::Entries.new :xmllines => xmllines
-      
-      if status
-        entries.select do |entry|
-          entry.status == status
-        end
-      else
-        entries
+
+      entries.select do |entry|
+        status.nil? || entry.status == status
       end
     end
 
@@ -168,37 +134,13 @@ module PVN::IO
       find_files_by_status 'modified'
     end
 
-    # returns log entries
-    def log cmdargs = SVNx::LogCommandArgs.new
-      # $$$ todo: this should be either @local if set, otherwise @svn (url)
-      # cmdargs.path = @local
-      cmd = SVNx::LogCommand.new cmdargs
-      SVNx::Log::Entries.new :xmllines => cmd.execute
-    end
-
     # returns log entries
     def logentries revision
       # use_cache should be conditional on revision:
-      # cmdargs[:use_cache] = false
-      cmdargs = SVNx::LogCommandArgs.new :path => @local, :revision => revision.to_s, :use_cache => false, :verbose => true
-      cmd = SVNx::LogCommand.new cmdargs
-      SVNx::Log::Entries.new :xmllines => cmd.execute
+      xmllines = SVNx::Exec.new.log @local, revision.to_s, nil, true, false
+      SVNx::Log::Entries.new :xmllines => xmllines
     end
     
-    # returns :added, :deleted, "modified"
-    def status
-      cmdargs = SVNx::StatusCommandArgs.new :path => @local
-      cmd = SVNx::StatusCommand.new :cmdargs => cmdargs
-      xmllines = cmd.execute
-      entries = SVNx::Status::Entries.new :xmllines => xmllines
-      entry = entries[0]
-      entry.status
-    end
-
-    # def line_counts
-    #   [ @svnelement && @svnelement.line_count, @fselement && @fselement.line_count ]
-    # end
-
     def <=> other
       @svn <=> other.svn
     end

data/lib/pvn/io/fselement.rb

@@ -2,12 +2,14 @@
 # -*- ruby -*-
 
 require 'rubygems'
-require 'riel'
+require 'riel/pathname'
+require 'logue/loggable'
 
 module PVN
   # A filesystem element (directory or file).
   class FSElement < Pathname
-    include Loggable
+    include Logue::Loggable
+    
     attr_reader :name
     
     def initialize name
@@ -18,5 +20,9 @@ module PVN
     def line_count
       readlines.size
     end
+
+    def to_s
+      super
+    end
   end
 end

data/lib/pvn/log/command.rb

@@ -16,9 +16,9 @@ module PVN::Log
     subcommands [ "log" ]
     description "Print log messages for the given files."
     usage       "[OPTIONS] FILE..."
-    summary     [ "Prints the log entries for the given files, with colorized",
+    summary     [ "Prints the log entries for the given files, with colorized ",
                   "output. Unlike 'svn log', which prints all log entries, ",
-                  "'pvn log' prints #{DEFAULT_LIMIT} entries by default.",
+                  "'pvn log' prints #{DEFAULT_LIMIT} entries by default. ",
                   "As with other pvn subcommands, 'pvn log' accepts relative ",
                   "revisions."
                 ]

data/lib/pvn/log/entries.rb

@@ -1,42 +1,28 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-require 'svnx/log/command'
+require 'logue/loggable'
+require 'svnx/exec'
 require 'svnx/log/entries'
 
 module PVN::Log
   class Entries < SVNx::Log::Entries
-    include Loggable
+    include Logue::Loggable
 
     def initialize path, options
-      cmdargs = create_cmd_args options, path
-      cmdargs[:path] = path
-      
-      info "cmdargs: #{cmdargs}".magenta
+      revision = options.revision
+      limit = limit options
+      verbose = options.files
 
-      logargs = SVNx::LogCommandArgs.new cmdargs
-      cmd = SVNx::LogCommand.new logargs
-      
-      super :xmllines => cmd.execute
-
-      info { "options: #{options}" }
-      info { "options.user: #{options.user}".yellow }
-    end
-
-    def create_cmd_args options, path
-      cmdargs = Hash.new
-      cmdargs[:path] = path      
-
-      [ :limit, :revision ].each do |field|
-        cmdargs[field] = options.send field
-      end
-
-      cmdargs[:verbose] = options.files
-      
       # we can't cache this, because we don't know if there has been an svn
       # update since the previous run:
-      cmdargs[:use_cache] = false
-      cmdargs
+      use_cache = false
+      xmllines = SVNx::Exec.new.log path, revision, limit, verbose, use_cache
+      super :xmllines => xmllines
+    end
+
+    def limit options
+      options.limit
     end
   end
 end

data/lib/pvn/log/formatter/date_formatter.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'date'
+
+module PVN::Log
+  # a format for the date.
+  class DateFormatter
+    DEFAULT_FORMAT = "%y-%m-%d %H:%M:%S"
+
+    def format date
+      dt = date.kind_of?(DateTime) ? date : DateTime.parse(date.to_s)
+      dt.strftime DEFAULT_FORMAT
+    end
+  end
+end