pvn 0.0.1

data/lib/pvn/log/logfactory.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'riel'
+require 'pvn/log/logentry'
+require 'pvn/base/textlines'
+
+module PVN; module Log; end; end
+
+module PVN;;Log
+  SVN_LOG_SUMMARY_LINE_RE = Regexp.new('^r(\d+) \| (\S+) \| (\S+) (\S+) (\S+) \((.*)\) \| (\d+) lines?$')
+  SVN_LOG_SEPARATOR_LINE_RE = Regexp.new('^-{72}$')
+  SVN_LOG_VERBOSE_START_RE = Regexp.new('^Changed paths:$')
+  SVN_LOG_FILE_NAME_RE = Regexp.new('^   (\w) (.*)$')
+
+  class TextFactory
+    include Loggable
+
+    def initialize lines
+      @textlines = TextLines.new lines
+      @entries = nil
+    end
+
+    def entries
+      @entries ||= read_entries
+    end
+
+    def read_entries
+      entries = Array.new
+      while entry = create_next_entry
+        entries << entry
+      end
+      entries
+    end
+
+    def match_line re, offset = 0
+      @textlines.match_line re, offset
+    end
+
+    def advance_line nlines = 1
+      @textlines.advance_line nlines
+    end
+
+    def match_log_start_line
+      match_line(SVN_LOG_SEPARATOR_LINE_RE) && match_line(SVN_LOG_SUMMARY_LINE_RE, 1)
+    end
+
+    def has_line?
+      @textlines.has_line?
+    end
+
+    def current_line
+      @textlines.line
+    end
+
+    def read_comment
+      comment = Array.new
+      while has_line? && !match_line(SVN_LOG_SEPARATOR_LINE_RE)
+        comment << current_line.chomp
+        advance_line
+      end
+      comment
+    end
+
+    def read_files
+      advance_line
+      files = Array.new
+      while (ln = current_line) && !ln.strip.empty?
+        md = match_line(SVN_LOG_FILE_NAME_RE)
+        changetype = md[1]
+        fname = md[2]
+        files << fname
+        advance_line
+      end        
+      files
+    end
+
+    def create_entry fielddata
+      advance_line 2
+      fields = Hash[Entry::FIELDS.zip fielddata[1 .. -1]]
+      if match_line SVN_LOG_VERBOSE_START_RE
+        fields[:files] = read_files
+      end
+      advance_line
+      fields[:comment] = read_comment
+      return Entry.new fields
+    end
+
+    def create_next_entry
+      while has_line?
+        if fielddata = match_log_start_line
+          return create_entry fielddata
+        else
+          advance_line
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/pvn/log/logoptions.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'synoption/set'
+require 'synoption/option'
+require 'synoption/boolean_option'
+require 'pvn/subcommands/revision/revision_regexp_option'
+
+module PVN
+  DEFAULT_LIMIT = 5
+
+  class LimitOption < Option
+    def initialize lmtargs = Hash.new
+      super :limit, '-l', "the number of log entries", DEFAULT_LIMIT, :negate => [ %r{^--no-?limit} ]
+    end
+  end
+
+  class VerboseOption < BooleanOption
+    def initialize optargs = Hash.new
+      super :verbose, '-v', [ "include the files in the change" ], false
+    end
+  end
+
+  class FormatOption < BooleanOption
+    def initialize optargs = Hash.new
+      super :format, '-f', "use the custom (colorized) format", true, :negate => [ '-F', %r{^--no-?format} ], :as_cmdline_option => nil
+    end
+  end
+
+  class LogOptionSet < OptionSet
+    attr_accessor :revision
+    attr_reader :format
+    
+    def initialize
+      super
+
+      add LimitOption.new
+      @revision = add RevisionRegexpOption.new(:unsets => :limit)
+      @verbose  = add VerboseOption.new
+      @format   = add FormatOption.new
+    end
+  end
+end

data/lib/pvn/pct/linecount.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module PVN
+  class LineCount
+    attr_accessor :to
+    attr_accessor :from
+    attr_accessor :name
+
+    def initialize args = Hash.new
+      @name = args[:name] || ""
+      @to   = args[:to]   || 0
+      @from = args[:from] || 0
+    end
+
+    def +(other)
+      # the new wc has the name of the lhs of the add:
+      self.class.new :to => @to + other.to, :from => @from + other.from, :name => @name
+    end
+
+    def diff
+      @to - @from
+    end
+
+    def diffpct
+      @from.zero? ? "0" : 100.0 * diff / @from
+    end
+
+    def write
+      printf "%8d %8d %8d %8.1f%% %s\n", @from, @to, diff, diffpct, @name
+    end
+  end
+end

data/lib/pvn/pct/pctcmd.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'system/command'
+require 'pvn/pct/linecount'
+require 'pvn/io/fselement'
+require 'pvn/svn/svnelement'
+require 'pvn/svn/svnroot'
+require 'pvn/io/element'
+
+module PVN
+  class PctOptionSet < OptionSet
+    attr_accessor :revision
+    
+    def initialize
+      super
+      @revision = add RevisionRegexpOption.new
+    end
+  end
+
+  class PctCommand < Command
+    DEFAULT_LIMIT = 5
+    COMMAND = "pct"
+
+    self.doc do |doc|
+      doc.subcommands = [ COMMAND ]
+      doc.description = "Print the comparison of size of locally-changed files."
+      doc.usage       = "[OPTIONS] FILE..."
+      doc.summary     = [ "Prints the changes in the size (length) of files that have ",
+                          "been changed locally, to show the extent to which they have",
+                          "increased or decreased. The columns are:",
+                          " - length in svn repository",
+                          " - length in local version",
+                          " - difference",
+                          " - percentage change",
+                          " - file name",
+                          "When more than one file is specified, the total is displayed",
+                          "as the last line." ]
+      doc.examples   << [ "pvn pct main.c", "Prints the number of lines and percentage by which main.c has changed." ]
+    end
+
+    def initialize args
+      # not calling super, since all of our stuff goes on in this ctor.
+
+      info "args: #{args}"
+
+      @options = PctOptionSet.new
+
+      @options.process self, args, args[:command_args]
+      info "args: #{args}"
+
+      files = get_files @options.arguments
+      info "files: #{files.inspect}"
+
+      rev = @options.revision.value
+      info "rev: #{rev}"
+      
+      @output = Array.new
+
+      totallc = LineCount.new :name => "total"
+
+      files.sort.each do |file|
+        info "file: #{file}"
+
+        fromlc, tolc = if rev
+                         [ file.svn.line_count(rev - 1), file.svn.line_count(rev) ]
+                       else
+                         [ file.svn.line_count(rev), file.local.line_count ]
+                       end
+
+        info "fromlc: #{fromlc}"
+        info "tolc: #{tolc}"
+        
+        filelc = LineCount.new :from => fromlc, :to => tolc, :name => file.local.name
+        filelc.write
+
+        totallc += filelc
+        info "totallc: #{totallc.inspect}"
+      end
+
+      if files.size > 1
+        totallc.write
+      end
+    end
+
+    def to_command subcmd, *args
+      cmd = "svn #{subcmd}"
+      info "cmd: #{cmd}"
+      info "args: #{args}"
+      args = args.flatten
+
+      revcl = @options.revision.to_command_line
+      if revcl
+        cmd << " " << revcl.join(" ")
+      end
+      cmd << " " << Util::quote_list(args)
+      info "cmd: #{cmd}".on_blue
+      cmd
+    end
+
+    def get_changed_files filespec
+      rev = @options.revision.value
+      info "rev: #{rev}"
+      
+      if rev
+        get_changed_files_revision filespec
+      else
+        get_changed_files_wc filespec
+      end
+    end
+
+    def svn_fullname_to_local_file svnname
+      svnelement = SVNElement.new :name => '.'
+      info "svnelement.info: #{svnelement.info}"
+
+      fullurl = svnelement.info[:repository_root] + svnname
+      info "fullurl        : #{fullurl}".yellow
+
+      svnroot = SVNRootElement.new
+      info "svnroot        : #{svnroot}".yellow
+
+      info "svnroot.info   : #{svnroot.info}".yellow
+
+      here = SVNElement.new :name => '.'
+
+      hereinfo    = here.info
+      info "hereinfo[:url] : #{hereinfo[:url]}".yellow
+      reporoot    = hereinfo[:repository_root]
+
+      info "reporoot       : #{reporoot}".yellow
+
+      info "svnroot[:url]  : #{svnroot.info[:url]}".yellow
+
+      rootpath = svnroot.name
+      rooturl  = svnroot.info[:url]
+
+      info "rootpath       : #{rootpath}".yellow
+      info "rooturl        : #{rooturl}".yellow
+
+      if fullurl.index(rooturl) == 0
+        localname = fullurl[rooturl.length .. -1]
+        info "localname      : #{localname}".yellow
+        localname
+      else
+        info "fullurl        : #{fullurl}".on_red
+        nil
+      end
+
+    end
+
+    def get_changed_files_revision filespec
+      lc = LogCommand.new :revision => @options.revision.value, :verbose => true
+      info "lc: #{lc}"
+      entry = lc.entries[0]
+      return Array.new if entry.nil?
+
+      # entry.write true
+
+      files = entry.files.collect do |svnfile|
+        localfile = svn_fullname_to_local_file svnfile
+        Element.new :file => localfile
+      end
+      info "files: #{files}".yellow
+      files
+    end
+
+    def get_changed_files_wc filespec
+      files = Array.new
+      cmd = to_command "st", filespec
+      IO.popen cmd do |io|
+        io.each do |line|
+          info "line: #{line}".yellow
+          next if line.index %r{^\?}
+          pn = Element.new :file => line.chomp[8 .. -1]
+          files << pn if pn.local.file?
+        end
+      end
+      info "files: #{files}".red
+      files
+    end
+    
+    def get_files fileargs
+      info "fileargs: #{fileargs}".yellow
+
+      files = Array.new
+      if fileargs.empty?
+        files = get_changed_files fileargs
+      else
+        fileargs.collect do |fn|
+          elmt = Element.new :file => fn
+          if elmt.local.directory?
+            files.concat get_changed_files(fn)
+          else
+            files << elmt
+          end
+        end
+      end
+
+      info "files: #{files}".yellow
+
+      files
+    end
+  end
+end

data/lib/pvn/pct/statcmd.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module PVN
+  class StatOptionSet < OptionSet
+    attr_accessor :revision
+    
+    def initialize
+      super
+      @revision = add RevisionRegexpOption.new
+    end
+  end
+end

data/lib/pvn/revision/entry.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/log/entries'
+
+module PVN::Revision
+  DATE_REGEXP = Regexp.new '^\{(.*?)\}'
+  SVN_REVISION_WORDS = %w{ HEAD BASE COMMITTED PREV }
+  RELATIVE_REVISION_RE = Regexp.new '^([\+\-])(\d+)$'
+
+  # Returns the Nth revision from the given logging output.
+
+  # -n means to count from the end of the list.
+  # +n means to count from the beginning of the list.
+  #  n means the literal revision number.  
+  class Entry
+    include Loggable
+
+    attr_reader :value
+    attr_reader :log_entry
+
+    class << self
+      alias_method :orig_new, :new
+
+      def new args = Hash.new
+        value = args[:value]
+
+        # these are lines from "svn log -v <file>"
+        xmllines = args[:xmllines]
+        if xmllines.kind_of? Array
+          xmllines = xmllines.join ''
+        end
+
+        case value
+        when Fixnum
+          if value < 0
+            RelativeEntry.orig_new value, xmllines
+          else
+            FixnumEntry.orig_new value
+          end
+        when String
+          if SVN_REVISION_WORDS.include? value
+            StringEntry.orig_new value
+          elsif md = RELATIVE_REVISION_RE.match(value)
+            RelativeEntry.orig_new md[0].to_i, xmllines
+          elsif DATE_REGEXP.match value
+            StringEntry.orig_new value
+          else
+            FixnumEntry.orig_new value.to_i
+          end
+        when Date
+          # $$$ this (and Time) will probably have to be converted to svn's format
+          raise "date not yet handled"
+        when Time
+          raise "time not yet handled"
+        end          
+      end
+
+      def matches_relative? str
+        RELATIVE_REVISION_RE.match str
+      end
+    end
+
+    def initialize value
+      @value = value
+    end
+  end
+
+  class FixnumEntry < Entry
+  end
+
+  class StringEntry < Entry
+  end
+
+  class RelativeEntry < FixnumEntry
+    def initialize value, xmllines
+      raise "cannot determine relative revision without xmllines" unless xmllines
+
+      logentries = SVNx::Log::Entries.new :xmllines => xmllines
+
+      nentries = logentries.size
+
+      # logentries are in descending order, so the most recent one is index 0
+
+      if value.abs > nentries
+        raise "ERROR: no entry for revision: #{value.abs}; number of entries: #{nentries}"
+      else
+        idx = value < 0 ? -1 + value.abs : nentries - value
+        @log_entry = logentries[idx]
+        super @log_entry.revision.to_i
+      end
+    end
+  end
+end

data/lib/pvn/revision.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'riel'
+require 'pvn/log/logcmd'
+
+module PVN
+  # Returns the Nth revision from the given logging output.
+
+  # -n means to count from the end of the list.
+  # +n means to count from the beginning of the list.
+  #  n means the literal revision number.  
+  class Revision
+    include Loggable
+
+    DATE_REGEXP = Regexp.new('^\{(.*?)\}')
+    SVN_REVISION_WORDS = %w{ HEAD BASE COMMITTED PREV }
+
+    def self.revision_from_args optset, optargs
+      revarg = optargs.shift
+      RIEL::Log.debug "revarg: #{revarg}"
+      RIEL::Log.debug "optargs: #{optargs}"
+
+      rev = Revision.new(:fname => optset.arguments[0], :value => revarg, :use_cache => false).revision
+      RIEL::Log.debug "rev: #{rev}"
+
+      if rev.nil?
+        raise ArgumentError.new "invalid revision: #{revarg} on #{optargs[-1]}"
+      end
+      rev
+    end
+    
+    attr_reader :revision
+
+    def initialize args = Hash.new
+      debug "args        : #{args}".yellow
+      value = args[:value]
+      num = value.kind_of?(String) ? value.strip : value
+      debug "num        : #{num}".yellow
+      @fname = args[:fname]
+      debug "fname      : #{@fname}".yellow
+      
+      @revision = nil
+
+      from, to = num.kind_of?(String) ? num.split(':') : num
+      info "from: #{from}; to: #{to}".on_blue
+      info "from: #{from.class}; to: #{to.class}".on_blue
+
+      @revision = convert_to_revision from
+      if to
+        @revision += ':' + convert_to_revision(to)
+      end
+
+      info "@revision: #{@revision}; #{@revision.class}"
+    end
+
+    def to_s
+      @revision
+    end
+
+    def convert_to_revision arg
+      if SVN_REVISION_WORDS.include? arg
+        info "word: #{arg}"
+        arg
+      elsif neg = Integer.negative?(arg)
+        info "neg: #{arg}"
+        get_negative_revision neg
+      elsif arg.kind_of? Fixnum
+        info "fixnum: #{arg}"
+        arg.to_s
+      elsif md = DATE_REGEXP.match(arg)
+        info "md: #{md.inspect}".on_red
+        md[0]
+      elsif md = %r{^\+(\d+)}.match(arg)
+        arg = md[1].to_i
+        debug "arg: #{arg}"
+        get_revision @fname, nil, arg
+      else
+        arg.to_s
+      end
+    end
+
+    def get_negative_revision neg
+      debug "neg        : #{neg}"
+
+      # if these two are the same number (revision(-3) == revision(-2)) then
+      # we're at the end/beginning of the list.
+      currrev = get_negative_revision_unchecked neg
+      if neg == -1
+        debug "currrev: #{currrev}"
+        @revision = currrev
+      else
+        debug "neg        : #{neg}"
+        prevrev = get_negative_revision_unchecked neg + 1
+        
+        debug "prevrev: #{prevrev}"
+        debug "currrev: #{currrev}"
+
+        # $$$ does -r 123 -l 2 == -r 123 -l 3?
+        @revision = prevrev == currrev ? nil : currrev
+        # @revision = prevrev == currrev ? currrev : currrev
+      end
+    end
+
+    def get_negative_revision_unchecked neg
+      # count the limit backward, and get the "first" (last) match
+      limit = -1 * neg
+      get_revision @fname, limit, 1
+    end
+
+    def get_revision fname, limit, num
+      logcmd = LogCommand.new :limit => limit, :command_args => [ fname ]
+      entries = logcmd.entries
+      entry = entries[-1 * num]
+      entry && entry.revision.to_i
+    end
+  end
+end

data/lib/pvn/subcommands/base/clargs.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module PVN; module App; end; end
+
+module PVN::App::Base
+  class CmdLineArgs
+    include Loggable
+
+    class << self
+      def has_option name
+        define_method name do
+          info "name: #{name}"
+          self.instance_eval do
+            meth = name
+            info "meth: #{meth}"
+            val = @optset.send name
+            info "val: #{val}"
+            val
+          end
+        end
+      end
+    end
+
+    attr_reader :unprocessed
+
+    def initialize optset, args
+      @optset = optset
+      process args
+      @unprocessed = args
+    end
+
+    def process args
+      options_processed = Array.new
+      
+      while !args.empty?
+        processed = false
+        @optset.options.each do |opt|
+          if opt.process args
+            processed = true
+            options_processed << opt
+          end
+        end
+
+        break unless processed
+      end
+
+      options_processed.each do |opt|
+        opt.post_process @optset, args
+      end
+    end
+  end
+end