spicycode-rcov 0.8.1.3.0

data/lib/rcov/lowlevel.rb

@@ -0,0 +1,147 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# See LEGAL and LICENSE for licensing information.
+
+require 'rcov/version'
+
+module Rcov
+
+  # RCOV__ performs the low-level tracing of the execution, gathering code
+  # coverage information in the process. The C core made available through the
+  # rcovrt extension will be used if possible. Otherwise the functionality
+  # will be emulated using set_trace_func, but this is very expensive and
+  # will fail if other libraries (e.g. breakpoint) change the trace_func.
+  #
+  # Do not use this module; it is very low-level and subject to frequent
+  # changes. Rcov::CodeCoverageAnalyzer offers a much more convenient and
+  # stable interface.
+module RCOV__
+  COVER = {}
+  CALLSITES = {}
+  DEFSITES = {}
+  pure_ruby_impl_needed = true
+  unless defined? $rcov_do_not_use_rcovrt 
+    begin
+      require 'rcovrt'
+      abi = [0,0,0]
+      begin
+        abi = RCOV__.ABI
+        raise if abi[0] != RCOVRT_ABI[0] || abi[1] < RCOVRT_ABI[1]
+        pure_ruby_impl_needed = false
+      rescue
+        $stderr.puts <<-EOF
+The rcovrt extension I found was built for a different version of rcov.
+The required ABI is:              #{RCOVRT_ABI.join(".")}
+Your current rcovrt extension is: #{abi.join(".")}
+
+Please delete rcovrt.{so,bundle,dll,...} and install the required one.
+        EOF
+        raise LoadError
+      end
+    rescue LoadError
+      $stderr.puts <<-EOF
+
+Since the rcovrt extension couldn't be loaded, rcov will run in pure-Ruby
+mode, which is about two orders of magnitude slower.
+
+If you're on win32, you can find a pre-built extension (usable with recent
+One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
+
+      EOF
+    end
+  end
+
+  if pure_ruby_impl_needed
+    methods = %w[install_coverage_hook remove_coverage_hook reset_coverage 
+                 install_callsite_hook remove_callsite_hook reset_callsite 
+                 generate_coverage_info generate_callsite_info]
+    sklass = class << self; self end
+    (methods & sklass.instance_methods).each do |meth|
+      sklass.class_eval{ remove_method meth }
+    end
+    
+    @coverage_hook_activated = @callsite_hook_activated = false
+
+    def self.install_coverage_hook # :nodoc:
+      install_common_hook
+      @coverage_hook_activated = true
+    end
+    
+    def self.install_callsite_hook # :nodoc:
+      install_common_hook
+      @callsite_hook_activated = true
+    end
+    
+    def self.install_common_hook # :nodoc:
+      set_trace_func lambda {|event, file, line, id, binding, klass|
+        next unless SCRIPT_LINES__.has_key? file
+        case event
+        when 'call'
+          if @callsite_hook_activated
+            receiver = eval("self", binding)
+            klass = class << klass; self end unless klass === receiver
+            begin
+              DEFSITES[[klass.to_s, id.to_s]] = [file, line]
+            rescue Exception
+            end
+            caller_arr = self.format_backtrace_array(caller[1,1])
+            begin
+              hash = CALLSITES[[klass.to_s, id.to_s]] ||= {}
+              hash[caller_arr] ||= 0
+              hash[caller_arr] += 1
+              #puts "#{event} #{file} #{line} #{klass.inspect} " +
+              #     "#{klass.object_id} #{id} #{eval('self', binding)}"
+            rescue Exception
+            end
+          end
+        when 'c-call', 'c-return', 'class'
+          return
+        end
+        if @coverage_hook_activated
+          COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
+          COVER[file][line - 1] ||= 0
+          COVER[file][line - 1] += 1
+        end
+      }
+    end
+
+    def self.remove_coverage_hook # :nodoc:
+      @coverage_hook_activated = false
+      set_trace_func(nil) if !@callsite_hook_activated
+    end
+    
+    def self.remove_callsite_hook # :nodoc:
+      @callsite_hook_activated = false
+      set_trace_func(nil) if !@coverage_hook_activated
+    end
+
+    def self.reset_coverage # :nodoc:
+      COVER.replace({})
+    end
+
+    def self.reset_callsite # :nodoc:
+      CALLSITES.replace({})
+      DEFSITES.replace({})
+    end
+
+    def self.generate_coverage_info # :nodoc:
+      Marshal.load(Marshal.dump(COVER))
+    end
+
+    def self.generate_callsite_info # :nodoc:
+      [CALLSITES, DEFSITES]
+    end
+
+    def self.format_backtrace_array(backtrace)
+      backtrace.map do |line|
+        md = /^([^:]*)(?::(\d+)(?::in `(.*)'))?/.match(line)
+        raise "Bad backtrace format" unless md
+        [nil, md[3] ? md[3].to_sym : nil, md[1], (md[2] || '').to_i]
+      end
+    end
+  end
+end # RCOV__
+
+end # Rcov
+
+# vi: set sw=2:

data/lib/rcov/rant.rb

@@ -0,0 +1,87 @@
+
+require 'rant/rantlib'
+
+module Rant          # :nodoc:
+  module Generators  # :nodoc:
+  class Rcov         # :nodoc:
+    def self.rant_gen(app, ch, args, &block)
+      if !args || args.empty?
+        self.new(app, ch, &block)
+      elsif args.size == 1
+        name, pre = app.normalize_task_arg(args.first, ch)
+        self.new(app, ch, name, pre, &block)
+      else
+        app.abort_at(ch,
+                     "Rcov takes only one additional argument, " +
+                     "which should be like one given to the `task' command.")
+      end
+    end
+
+    attr_accessor :verbose
+    attr_accessor :libs
+    attr_accessor :test_dirs
+    attr_accessor :pattern
+    attr_accessor :test_files
+    attr_accessor :rcov_opts
+    # Directory where to put the generated XHTML reports
+    attr_accessor :output_dir
+
+    def initialize(app, cinf, name = :rcov, prerequisites = [], &block)
+      @rac = app
+      @name = name
+      @pre = prerequisites
+      #@block = block
+      @verbose = nil
+      cf = cinf[:file]
+      @libs = []
+      libdir = File.join(File.dirname(File.expand_path(cf)), 'lib')
+      @libs << libdir if test(?d, libdir)
+      @rcov_opts = ["--text-report"]
+      @test_dirs = []
+      @pattern = nil
+      @test_files = nil
+      yield self if block_given?
+      @pattern = "test*.rb" if @pattern.nil? && @test_files.nil?
+      @output_dir ||= "coverage"
+
+      @pre ||= []
+      # define the task
+      app.task(:__caller__ => cinf, @name => @pre) { |t|
+        args = []
+        if @libs && !@libs.empty?
+          args << "-I#{@libs.join File::PATH_SEPARATOR}"
+        end
+        if rcov_path = ENV['RCOVPATH'] 
+          args << rcov_path
+        else
+          args << "-S" << "rcov"
+        end
+        args.concat rcov_opts
+        args << "-o" << @output_dir
+        if test(?d, "test")
+          @test_dirs << "test" 
+        elsif test(?d, "tests")
+          @test_dirs << "tests"
+        end
+        args.concat filelist
+        app.context.sys.ruby args
+      }
+    end
+    
+    def filelist
+      return @rac.sys[@rac.var['TEST']] if @rac.var['TEST']
+      filelist = @test_files || []
+      if filelist.empty?
+        if @test_dirs && !@test_dirs.empty?
+          @test_dirs.each { |dir|
+            filelist.concat(@rac.sys[File.join(dir, @pattern)])
+          }
+        else
+          filelist.concat(@rac.sys[@pattern]) if @pattern
+        end
+      end
+      filelist
+    end
+  end	# class Rcov
+  end   # module Generators
+end	# module Rant

data/lib/rcov/rcovtask.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+# Define a task library for performing code coverage analysis of unit tests
+# using rcov.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rcov
+
+  # Create a task that runs a set of tests through rcov, generating code
+  # coverage reports.
+  #
+  # Example:
+  #   
+  #   require 'rcov/rcovtask'
+  #   
+  #   Rcov::RcovTask.new do |t|
+  #     t.libs << "test"
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.verbose = true
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "RCOVOPTS=options" command line option,
+  # then the given options are passed to rcov.
+  #
+  # If rake is invoked with a "RCOVPATH=path/to/rcov" command line option,
+  # then the given rcov executable will be used; otherwise the one in your
+  # PATH will be used.
+  #
+  # Examples:
+  #
+  #   rake rcov                           # run tests normally
+  #   rake rcov TEST=just_one_file.rb     # run just one test file.
+  #   rake rcov RCOVOPTS="-p"             # run in profile mode
+  #   rake rcov RCOVOPTS="-T"             # generate text report
+  #
+  class RcovTask < Rake::TaskLib
+
+    # Name of test task. (default is :rcov)
+    attr_accessor :name
+
+    # List of directories to added to $LOAD_PATH before running the
+    # tests. (default is 'lib')
+    attr_accessor :libs
+
+    # True if verbose test output desired. (default is false)
+    attr_accessor :verbose
+
+    # Request that the tests be run with the warning flag set.
+    # E.g. warning=true implies "ruby -w" used to run the tests.
+    attr_accessor :warning
+
+    # Glob pattern to match test files. (default is 'test/test*.rb')
+    attr_accessor :pattern
+    
+    # Array of commandline options to pass to ruby when running the rcov loader.
+    attr_accessor :ruby_opts
+
+    # Array of commandline options to pass to rcov. An explicit
+    # RCOVOPTS=opts on the command line will override this. (default
+    # is <tt>["--text-report"]</tt>)
+    attr_accessor :rcov_opts
+
+    # Output directory for the XHTML report.
+    attr_accessor :output_dir
+
+    # Explicitly define the list of test files to be included in a
+    # test.  +list+ is expected to be an array of file names (a
+    # FileList is acceptable).  If both +pattern+ and +test_files+ are
+    # used, then the list of test files is the union of the two.
+    def test_files=(list)
+      @test_files = list
+    end
+
+    # Create a testing task.
+    def initialize(name=:rcov)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @test_files = nil
+      @verbose = false
+      @warning = false
+      @rcov_opts = ["--text-report"]
+      @ruby_opts = []
+      @output_dir = "coverage"
+      yield self if block_given?
+      @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
+      define
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      actual_name = Hash === name ? name.keys.first : name
+      unless Rake.application.last_comment
+        desc "Analyze code coverage with tests" + 
+          (@name==:rcov ? "" : " for #{actual_name}")
+      end
+      task @name do
+	run_code = ''
+	RakeFileUtils.verbose(@verbose) do
+	  run_code =
+	    case rcov_path
+	    when nil, ''
+              "-S rcov"
+            else %!"#{rcov_path}"!
+	    end
+          ruby_opts = @ruby_opts.clone
+          ruby_opts.push( "-I#{lib_path}" )
+          ruby_opts.push run_code
+	  ruby_opts.push( "-w" ) if @warning
+	  ruby ruby_opts.join(" ") + " " + option_list +
+            %[ -o "#{@output_dir}" ] +
+	    file_list.collect { |fn| %["#{fn}"] }.join(' ')
+	end
+      end
+
+      desc "Remove rcov products for #{actual_name}"
+      task paste("clobber_", actual_name) do
+	rm_r @output_dir rescue nil
+      end
+
+      clobber_task = paste("clobber_", actual_name)
+      task :clobber => [clobber_task]
+
+      task actual_name => clobber_task
+      self
+    end
+
+    def rcov_path # :nodoc:
+      ENV['RCOVPATH']
+    end
+
+    def option_list # :nodoc:
+      ENV['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+    end
+
+    def file_list # :nodoc:
+      if ENV['TEST']
+	FileList[ ENV['TEST'] ]
+      else
+	result = []
+	result += @test_files.to_a if @test_files
+	result += FileList[ @pattern ].to_a if @pattern
+	FileList[result]
+      end
+    end
+  end
+end
+