rscm-accurev 0.0.4 → 0.0.6

data/lib/rscm/scm/accurev/exception.rb

@@ -0,0 +1,38 @@
+# -*- ruby -*-
+#
+# = exception.rb
+#
+# Exception classes for RSCM::Accurev
+#
+# Includes:
+#
+# * AccurevException
+#
+# * StaleWorkspaceException
+#
+module RSCM
+  module Accurev
+    
+    #
+    # General exception class for errors processing commands.
+    #
+    # @attr error_msg Error message output by accurev.
+    #
+    class AccurevException < Exception
+      attr_reader :error_msg
+      def initialize( msg, error_msg=nil )
+        super( "#{msg}: #{error_msg}" )
+        @error_msg = error_msg
+      end     
+    end
+    
+    #
+    # Exception thrown when an update is performed
+    # on a workspace with unkept/unanchored modifications.
+    # Accurev requires that all modifications be handled before
+    # an update is performed.
+    #
+    class StaleWorkspaceException < AccurevException; end
+
+  end
+end

data/lib/rscm/scm/accurev/xml.rb

@@ -109,6 +109,11 @@ module RSCM::Accurev
       end.send( :define_method, "element_name" ) {name}
     end
 
+    # currently advisory only
+    def self.children( *kidtypes )
+      # nothing XXX
+    end
+
     def initialize( element=nil )
       @children = {}
       unless element.nil?
@@ -121,6 +126,18 @@ module RSCM::Accurev
       return self.children[key]
     end
 
+    def to_s
+      s = "<#{self.class.element_name} "
+      self.instance_variables.each do |a|
+        unless a == "@children"
+          attr = a.sub( /^@/, "" )
+          s += "#{attr}='#{self.send(attr)}' "
+        end
+      end
+      s += "/>"
+      return s
+    end
+
   protected
     # Does the work of calling object setters for each XML attribute.
     def set_from_element( e )
@@ -179,4 +196,29 @@ module RSCM::Accurev
     attr_accessor :error, :text_content
   end
 
+  #
+  # Version (element) records in a history transaction
+  #
+  class VersionData < ElementBackedClass
+    element_name 'version'
+    attr_accessor :path, :eid, :virtual, :real, :elem_type
+  end
+
+  # 
+  # Commit messages on transactions
+  #
+  class CommentData < ElementBackedClass
+    element_name 'comment'
+  end
+
+  #
+  # Data from "accurev hist" - transaction groups
+  # Contains one or more VersionData.
+  #
+  class TransactionData < ElementBackedClass
+    element_name 'transaction'
+    children VersionData, CommentData
+    attr_accessor :id, :type, :time, :user
+  end
+
 end

data/test/coverage/analyzer.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/ruby
+require 'erb'
+require 'fileutils'
+include FileUtils
+
+# 
+# usage:
+#   rake coverage
+#
+#
+
+trace_file = ARGV.shift
+output_dir = ARGV.shift
+template_file = ARGV.shift
+template_index = ARGV.shift
+
+if trace_file.nil? or output_dir.nil?
+  raise "Usage: $0 <tracefile> <output_dir> <template> <index_template>"
+end
+
+# stdout.printf("#%d:%s:%d:%s:%s: %s",
+#    get_thread_no,
+#    file,
+#    line,
+#    klass || '',
+#    EVENT_SYMBOL[event],
+#    get_line(file, line))
+
+puts "Reading trace data #{trace_file}..."
+files = {}
+File.open( trace_file, "r" ).each_line do |line|
+  data, linedump = line.split(/ /)
+  threadno, file, n, classname, eventsym = data.split(/:/)
+  files[file] ||= []
+  files[file][n.to_i] ||= 0
+  files[file][n.to_i] += 1
+end
+
+class Summary
+  attr_accessor :filename, :total_lines, :covered_lines
+  attr_accessor :lines, :seen
+  def initialize( filename )
+    @filename = filename
+    @total_lines = 0
+    @covered_lines = 0
+    @lines = []
+    @seen = []
+  end
+  def pct
+    @covered_lines.to_f / @total_lines.to_f
+  end
+  def htmlfile
+    @filename.gsub(/[\.\/]/, '_') + ".html"
+  end
+  def get_binding
+    binding
+  end
+end
+
+class IndexSummary
+  attr_accessor :summary
+  def get_binding
+    binding
+  end
+end
+
+def pretty( template, output_dir, s )
+  htmlfile = "#{output_dir}/#{s.htmlfile}"
+  puts htmlfile
+  File.open( htmlfile, "w" ) do |out|
+    rhtml = ERB.new( template )
+    out.print( rhtml.result( s.get_binding ) )
+  end
+end
+
+def index( template, output_dir, summaries )
+  idx = IndexSummary.new
+  idx.summary = summaries
+  puts "#{output_dir}/index.html"
+  File.open( "#{output_dir}/index.html", "w" ) do |out|
+    rhtml = ERB.new( template )
+    out.print( rhtml.result( idx.get_binding ) )
+  end
+end
+
+template = File.read( template_file )
+index_tmpl = File.read( template_index )
+
+puts "Outputting to #{output_dir}..."
+mkdir_p( output_dir )
+summary = {}
+files.each do |file, linelist|
+  s = Summary.new( file )
+  lineno = 0
+  File.open( file ).each_line do |line|
+    lineno += 1
+    seen_this = false
+    # basic: line was traced
+    unless linelist[lineno].nil?
+      seen_this = true
+    end
+    # misc: various comments, blank lines, other "untraceables"
+    #  mark them as seen
+    if line =~ /^\s*$/
+      seen_this = true
+    end
+    if line =~ /^\s*#/
+      seen_this = true
+    end
+    if line =~ /^\s*(require|class|module|end|else|include|def)/
+      seen_this = true
+    end
+    s.seen << seen_this
+    if seen_this
+      s.covered_lines += 1
+    end
+    s.total_lines +=1
+    s.lines << line
+  end
+  summary[file] = s
+  pretty( template, output_dir, summary[file] )
+end
+index( index_tmpl, output_dir, summary )
+
+
+
+

data/test/coverage/c_loader.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'tracer'
+
+# Initialize tracer
+TRACE_FILE = "xxx.trace"
+OUTPUT = File.open( TRACE_FILE, "w" )
+puts "Tracing to #{TRACE_FILE}"
+t = Tracer.new()
+def t.stdout
+  OUTPUT
+end
+def t.coverage_filter( event, file, line, id, binding, klass )
+  # skip c libs
+  return false if event == 'c-call'  
+  return false if event == 'c-return'
+  return false if event == 'class'
+  # skip any (other) core libs
+  return false if file =~ /^\//
+  # skip magical eval code
+  return false if file =~ /\(eval\)/
+  # log everything else
+  return true
+end
+t.add_filter( t.method(:coverage_filter).to_proc )
+
+# load in test files
+ARGV.each do |f|
+  load f unless f =~ /^-/
+end
+
+# turn tracing on: test::unit::autorunner runs test in an at_exit proc
+t.on
+  
+

data/test/coverage/cover.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+# set_trace_func proc do |event,file,line,id,binding,classname|
+#   'c-call' # call into clib -  file:line -> caller
+#   'c-return' # return out of clib -  file:line -> caller
+#   'call'  # call into ruby fn -  file:line -> fn def
+#   'class' # start class/mod def (only for dyn classes?)
+#   'end' # end class/mod def
+#   'line' # exec line
+#   'raise' # exception
+#   'return' # return from ruby fn -  file:line -> returning stmt
+# end
+
+require 'rexml/document'
+include REXML
+
+# defining script_lines make ruby dump all scripts into this hash
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+
+module Test
+
+  class Cover
+
+    attr_accessor :codebase_files
+
+    def initialize()
+      @codebase_files = []
+      # seen_lines is a hash of hashes
+      @seen_lines = {}
+    end
+
+    def trace_func( event, file, line, id, binding, classname )
+      return if event == 'c-call'
+      return if event == 'c-return'
+      return if event == 'class'
+      @seen_lines[file] ||= {}
+      @seen_lines[file][line] ||= 0
+      @seen_lines[file][line] += 1
+    end
+
+    def coverage()
+      set_trace_func( self.method(:trace_func).to_proc )
+      yield self
+      set_trace_func( nil )
+    end
+    
+    def coverage_all()
+      set_trace_func( self.method(:trace_func).to_proc )
+    end
+
+    def coverage_clear()
+      set_trace_func( nil )
+    end
+
+    def to_xml
+      doc = Document.new()
+      doc << XMLDecl.new()
+      root = Element.new( "coverage" )
+      doc << root
+      root.attributes['timestamp'] = Time.now
+      codebase = Element.new( "codebase" )
+      root << codebase
+      @codebase_files.each do |file|
+        e = Element.new( "file" )
+        e.attributes['name'] = file
+        codebase << e
+        if @seen_lines.has_key?( file )
+          seen = Element.new( "seen" )
+          e << seen
+          linehash = @seen_lines[file]
+          next unless SCRIPT_LINES__.has_key?( file )
+          linehash.each do |n,occur|
+            le = Element.new( "line" )
+            le.attributes['n'] = n
+            le.attributes['occur'] = occur
+            seen << le
+          end
+          ce = Element.new( "coverage" )
+          ce.attributes['seen'] = linehash.size
+          ce.attributes['total'] = SCRIPT_LINES__[file].size
+          ce.attributes['pct'] = linehash.size.to_f / SCRIPT_LINES__[file].size.to_f
+          seen << ce
+        end
+      end
+      return doc
+    end
+    
+  end
+
+end

data/test/coverage/coverage_loader.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+#require 'tracer'
+require 'test/cover'
+
+cover = Test::Cover.new()
+cover.coverage_all
+cover.codebase_files << "./lib/rscm/accurev.rb"
+cover.codebase_files << "./lib/rscm/scm/accurev/command.rb"
+
+#Tracer.on
+ARGV.each do |f|
+  load f unless f =~ /^-/
+end
+
+END {
+  cover.coverage_clear
+  File.open( "xxx.xml", "w" ) do |f|
+    f.puts( cover.to_xml )
+  end
+}

data/test/coverage/coveragetask.rb

@@ -0,0 +1,38 @@
+#/usr/bin/env ruby
+require 'rubygems'
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+  
+  class CoverageTask < TaskLib
+    attr_accessor :name
+    attr_accessor :libs
+    attr_accessor :test_files
+    attr_accessor :ruby_opts
+
+    def initialize( name=:coverage )
+      @name = name
+      @libs = ["lib"]
+      @test_files = nil
+      @ruby_opts = []
+      yield self if block_given?
+      define
+    end
+
+    def define
+      lib_path = @libs.join( File::PATH_SEPARATOR )
+      @ruby_opts.unshift( "-I#{lib_path}" )
+      task @name do
+        ruby @ruby_opts.join(" ") +
+          "test/coverage_loader.rb " +
+          file_list.collect {|fn| "\"#{fn}\"".join(" ")
+      end
+    end
+
+    def test_loader()
+      find_file( 'test/coverage_loader' ) or fail "I DIE"
+    end
+
+  end
+end

data/test/coverage/index_tmpl.html

@@ -0,0 +1,42 @@
+<html>
+  <head>
+    <title>Coverage Summary</title>
+  </head>
+  <body>
+    <h1>Coverage Summary</h1>
+
+    <%
+    def grad( pct )
+      zero_end = [255,0,0]
+      one_end = [0,255,0]
+      g = []
+      (0..2).each do |i|
+        g[i] = (pct * (one_end[i]-zero_end[i])) + zero_end[i]
+      end
+      return "#"+g.collect{|x| "%02x" % x }.join("")
+    end
+    %>
+    <p>
+      Codebase:
+      
+      <table border="1">
+	<tr>
+	  <td>File</td>
+	  <td>Lines</td>
+	  <td>Covered</td>
+	  <td>% Covered</td>
+	</tr>
+	
+	<% summary.each do |filename,s| %>
+	<tr>
+	  <td><a href="<%= s.htmlfile %>"><%= filename %></a></td>
+	  <td><%= s.total_lines %></td>
+	  <td><%= s.covered_lines %></td>
+	  <td bgcolor="<%= grad(s.pct) %>"><%= s.pct %></td>
+	</tr>
+	<% end %>
+
+      </table>
+    </p>
+  </body>
+</html>