hooligan495-rcov 0.8.1.3.0

data/README.emacs

@@ -0,0 +1,64 @@
+
+<tt>rcov.el</tt> allows you to use rcov from Emacs conveniently.
+* Run unit tests and jump to uncovered code by <tt>C-x `</tt>.
+* Run unit tests and save the current coverage status.
+* Run unit tests and jump to uncovered code introduced since the last run.
+* View cross-reference annotated code.
+
+== Installation
+
+Copy <tt>rcov.el</tt> to the appropriate directory, which is in load-path.
+Then require it.
+  (require 'rcov)
+
+
+== Usage
+
+There are some commands to run rcov in Emacs.
+All of them displays +rcov+ window, whose major-mode is compilation-mode.
+Therefore you can jump to uncovered code by <tt>C-x `</tt>.
+
++rcov-command-line+, +rcovsave-command-line+, and +rcovdiff-command-line+ define
+command line to run rcov.
+If you do not use +rcov+ from Rake, you must modify them.
+
+=== Finding uncovered code
+
+Type the following while editing your program:
+  M-x rcov
+  
+=== Setting the reference point
+
++rcov+'s <tt>--text-coverage-diff</tt> mode compares the current coverage status against
+the saved one. It therefore needs that information to be recorded
+before you write new code (typically right after you perform a commit) in
+order to have something to compare against.
+
+You can save the current status with the <tt>--save</tt> option.
+
+Type the following to save the current status in Emacs:
+  M-x rcovsave
+If you do not use +rcov+ from Rake, you must modify +rcovsave-command-line+ variable.
+
+=== Finding new uncovered code
+
+Type the following to save the current status in Emacs:
+  M-x rcovdiff
+
+=== Viewing cross-reference annotated code
+
+If you read cross-reference annotated code, issue
+  rake rcov RCOVOPTS='-a'
+at the beginning.
+This command creates +coverage+ directory and many *.rb files in it.
+Filenames of these Ruby scripts are converted from original path.
+You can browse them by normally <tt>C-x C-f</tt>.
+You can think of <tt>-a</tt> option as <tt>--xrefs</tt> option and output format is Ruby script.
+
+After find-file-ed annotated script, the major-mode is rcov-xref-mode,
+which is derived from ruby-mode and specializes navigation.
+
+<tt>Tab</tt> and <tt>M-Tab</tt> goes forward/backward links.
+<tt>Ret</tt> follows selected link.
+
+This feature is useful to read third-party code or to follow control flow.

data/README.en

@@ -0,0 +1,130 @@
+rcov  copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+rcov includes xx 0.1.0, copyright (c) 2005, ePark Labs, Inc. and contributors 
+
+rcov README
+============
+
+  rcov is a code coverage tool for Ruby. It is commonly used for viewing
+  overall test coverage of target code. It features:
+  * fast execution: 20-300 times faster than previous tools
+  * multiple analysis modes: standard, bogo-profile, "intentional testing",
+    dependency analysis...
+  * detection of uncovered code introduced since the last run ("differential
+    code coverage")
+  * fairly accurate coverage information through code linkage inference using 
+    simple heuristics
+  * cross-referenced XHTML and several kinds of text reports
+  * support for easy automation with Rake and Rant
+  * colorblind-friendliness
+
+Requirements
+------------
+
+  * Ruby 1.8
+  * (recommended) C compiler: you can also use rcov without the rcovrt
+    extension but rcov will be two orders of magnitude slower. The extension
+    requires Ruby 1.8.3 or later.
+    If you're on win32, you can find a pre-built rcovrt extension at
+	 http://eigenclass.org/hiki.rb?rcov
+
+
+Normal install
+--------------
+
+  De-compress the archive and enter its top directory.
+  Then type:
+
+   ($ su)
+    # ruby setup.rb
+
+  This simple step installs rcov under the default location for Ruby
+  libraries.  You can also customize the installation by supplying some
+  options to setup.rb.
+  Try "ruby setup.rb --help".
+
+  A normal (rcovrt-enabled) install requires Ruby >= 1.8.3 and a working C
+  toolchain; if you cannot compile Ruby extensions proceed as described below.
+  
+  If you're on win32, you can find a pre-built rcovrt extension at
+	 http://eigenclass.org/hiki.rb?rcov
+
+  You might have to install a "development package" (often named ruby-dev or
+  ruby1.8-dev), or alternatively build ruby from the sources, if the compiler
+  cannot find the headers (ruby.h and friends).
+
+Install without the rcovrt extension
+------------------------------------
+
+  ($su )
+  # ruby setup.rb all --without-ext
+
+  will install rcov without building the rcovrt extension.
+  
+Usage
+-----
+
+  In the common scenario, your tests are under test/ and the target code
+  (whose coverage you want) is in lib/. In that case, all you have to do is
+  use rcov to run the tests (instead of testrb), and a number of XHTML files
+  with the code coverage information will be generated, e.g.
+
+   rcov -Ilib test/*.rb
+
+  will execute all the .rb files under test/ and generate the code coverage
+  report for the target code (i.e. for the files in lib/) under coverage/. The
+  target code needs not be under lib/; rcov will detect is as long as it is
+  require()d by the tests. rcov is smart enough to ignore "uninteresting"
+  files: the tests themselves, files installed in Ruby's standard locations,
+  etc.  See  rcov --help  for the list of regexps rcov matches filenames
+  against.
+  
+  rcov can also be used from Rake; see README.rake or the RDoc documentation
+  for more information.  The Rakefile included in rcov's sources holds a few
+  tasks that run rcov on itself, producing a number of reports. You can try
+    rake rcov
+  preferably after a full install or
+    ruby setup.rb config
+    ruby setup.rb setup
+  so that the rcovrt extension can be used to speed up the process.
+  This will generate a cross-referenced XHTML report under coverage/.
+ 
+  rcov can output information in several formats, and perform different kinds
+  of analyses in addition to plain code coverage.  See  rcov --help  for a
+  description of the available options.
+
+License
+-------
+
+  rcov is licensed under the same terms as Ruby. See LICENSE.
+  rcov includes a copy of the xx library, which carries the following
+  copyright notice:
+
+ePark Labs Public License version 1
+Copyright (c) 2005, ePark Labs, Inc. and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+  3. Neither the name of ePark Labs nor the names of its contributors may be
+     used to endorse or promote products derived from this software without
+     specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Mauricio Fernandez <mfp@acm.org>

data/README.rake

@@ -0,0 +1,62 @@
+
+== Code coverage analysis automation with Rake
+
+Since 0.4.0, <tt>rcov</tt> features a <tt>Rcov::RcovTask</tt> task for rake
+which can be used to automate test coverage analysis.  Basic usage is as
+follows:
+
+ require 'rcov/rcovtask'
+ Rcov::RcovTask.new do |t|
+   t.test_files = FileList['test/test*.rb']
+   # t.verbose = true     # uncomment to see the executed command
+ end
+
+This will create by default a task named <tt>rcov</tt>, and also a task to
+remove the output directory where the XHTML report is generated.
+The latter will be named <tt>clobber_rcob</tt>, and will be added to the main
+<tt>clobber</tt> target.
+
+=== Passing command line options to <tt>rcov</tt>
+
+You can provide a description, change the name of the generated tasks (the
+one used to generate the report(s) and the clobber_ one) and pass options to
+<tt>rcov</tt>:
+
+ desc "Analyze code coverage of the unit tests."
+ Rcov::RcovTask.new(:coverage) do |t|
+   t.test_files = FileList['test/test*.rb']
+   t.verbose = true
+   ## get a text report on stdout when rake is run:
+   t.rcov_opts << "--text-report"  
+   ## only report files under 80% coverage
+   t.rcov_opts << "--threshold 80"
+ end
+
+That will generate a <tt>coverage</tt> task and the associated
+<tt>clobber_coverage</tt> task to remove the directory the report is dumped
+to ("<tt>coverage</tt>" by default).
+
+You can specify a different destination directory, which comes handy if you
+have several <tt>RcovTask</tt>s; the <tt>clobber_*</tt> will take care of
+removing that directory:
+
+ desc "Analyze code coverage for the FileStatistics class."
+ Rcov::RcovTask.new(:rcov_sourcefile) do |t|
+   t.test_files = FileList['test/test_FileStatistics.rb']
+   t.verbose = true
+   t.rcov_opts << "--test-unit-only"
+   t.output_dir = "coverage.sourcefile"
+ end
+ 
+ Rcov::RcovTask.new(:rcov_ccanalyzer) do |t|
+   t.test_files = FileList['test/test_CodeCoverageAnalyzer.rb']
+   t.verbose = true
+   t.rcov_opts << "--test-unit-only"
+   t.output_dir = "coverage.ccanalyzer"
+ end
+
+=== Options passed through the <tt>rake</tt> command line
+
+You can override the options defined in the RcovTask by passing the new
+options at the time you invoke rake. 
+The documentation for the Rcov::RcovTask explains how this can be done.

data/README.rant

@@ -0,0 +1,68 @@
+
+== Code coverage analysis automation with Rant
+
+Since 0.5.0, <tt>rcov</tt> features a <tt>Rcov</tt> generator for eant
+which can be used to automate test coverage analysis.  Basic usage is as
+follows:
+
+  require 'rcov/rant'
+ 
+  desc "Create a cross-referenced code coverage report."
+  gen Rcov do |g|
+    g.test_files = sys['test/test*.rb']
+  end
+
+This will create by default a task named <tt>rcov</tt>.
+
+=== Passing command line options to <tt>rcov</tt>
+
+You can provide a description, change the name of the generated tasks (the
+one used to generate the report(s) and the clobber_ one) and pass options to
+<tt>rcov</tt>:
+
+  desc "Create cross-referenced code coverage report."
+  gen Rcov, :coverage do |g|
+    g.test_files = sys['test/test*.rb']
+    g.rcov_opts << "--threshold 80" << "--callsites"
+  end
+
+That will generate a <tt>coverage</tt> task.
+
+You can specify a different destination directory, which comes handy if you
+have several rcov tasks:
+
+  desc "Analyze code coverage for the FileStatistics class."
+  gen Rcov, :rcov_sourcefile do |g|
+    g.libs << "ext/rcovrt"
+    g.test_files = sys['test/test_FileStatistics.rb']
+    g.rcov_opts << "--test-unit-only"
+    g.output_dir = "coverage.sourcefile"
+  end
+
+  desc "Analyze code coverage for CodeCoverageAnalyzer."
+  gen Rcov, :rcov_ccanalyzer do |g|
+    g.libs << "ext/rcovrt"
+    g.test_files = sys['test/test_CodeCoverageAnalyzer.rb']
+    g.rcov_opts << "--test-unit-only"
+    g.output_dir = "coverage.ccanalyzer"
+  end
+
+=== Options specified passed to the generator 
+
+The +Rcov+ generator recognizes the following options:
++libs+:: directories to be added to the <tt>$LOAD_PATH</tt>
++rcov_opts+:: array of options to be passed to rcov
++test_files+:: files to execute
++test_dirs+:: directories where to look for test files automatically
++pattern+:: pattern for automatic discovery of unit tests to be executed
++output_dir+:: directory where to leave the generated reports
+
++test_files+ overrides the combination of +test_dirs+ and +pattern+.
+
+
+=== Options passed through the <tt>rake</tt> command line
+
+You can override the options defined in the Rcov tasks by specifying them 
+using environment variables at the time rant is executed.
+  RCOVPATH=/my/modified/rcov rant rcov       # use the specified rcov executable
+  RCOVOPTS="--no-callsites -x foo" rant rcov # pass those options to rcov

data/README.vim

@@ -0,0 +1,47 @@
+
+<tt>rcov.vim</tt> allows you to run unit tests from vim and enter quickfix mode in
+order to jump to uncovered code introduced since the last run.
+
+== Installation
+Copy <tt>rcov.vim</tt> to the appropriate "compiler" directory (typically
+<tt>$HOME/.vim/compiler</tt>).
+
+== Usage
+
+=== Setting the reference point
+
++rcov+'s <tt>--text-coverage-diff</tt> mode compares the current coverage status against
+the saved one. It therefore needs that information to be recorded
+before you write new code (typically right after you perform a commit) in
+order to have something to compare against.
+
+You can save the current status with the <tt>--save</tt> option.
+If you're running +rcov+ from Rake, you can do something like
+  rake rcov_units RCOVOPTS="-T --save --rails"
+in order to take the current status as the reference point.
+
+=== Finding new uncovered code
+
+Type the following in command mode while editing your program:
+   :compiler rcov
+
+rcov.vim assumes +rcov+ can be invoked with a rake task (see 
+README.rake[link:files/README_rake.html] for
+information on how to create it). 
+
+You can then execute +rcov+ and enter quickfix mode by typing
+
+   :make <taskname>
+
+where taskname is the +rcov+ task you want to use; if you didn't override the
+default name in the Rakefile, just
+  
+   :make rcov
+
+will do.
+
+vim will then enter quickfix mode, allowing you to jump to the areas that were
+not covered since the last time you saved the coverage data.
+
+--------
+# vim: ft=text :

data/Rakefile

@@ -0,0 +1,193 @@
+# This Rakefile serves as an example of how to use Rcov::RcovTask.
+# Take a look at the RDoc documentation (or README.rake) for further
+# information.
+
+$:.unshift "lib" if File.directory? "lib"
+require 'rcov/rcovtask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+# Use the specified rcov executable instead of the one in $PATH
+# (this way we get a sort of informal functional test).
+# This could also be specified from the command like, e.g.
+#   rake rcov RCOVPATH=/path/to/myrcov
+ENV["RCOVPATH"] = "bin/rcov"
+
+# The following task is largely equivalent to:
+#   Rcov::RcovTask.new
+# (really!)
+desc "Create a cross-referenced code coverage report."
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.rcov_opts << "--xrefs"  # comment to disable cross-references
+  t.verbose = true
+end
+
+desc "Analyze code coverage for the FileStatistics class."
+Rcov::RcovTask.new(:rcov_sourcefile) do |t|
+  t.test_files = FileList['test/file_statistics_test.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.output_dir = "coverage.sourcefile"
+end
+
+Rcov::RcovTask.new(:rcov_ccanalyzer) do |t|
+  t.test_files = FileList['test/code_coverage_analyzer_test.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.output_dir = "coverage.ccanalyzer"
+end
+
+desc "Run the unit tests with rcovrt."
+if RUBY_PLATFORM == 'java'
+  Rake::TestTask.new(:test_rcovrt => ["lib/rcovrt.jar"]) do |t|
+    t.libs << "lib"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+else
+  Rake::TestTask.new(:test_rcovrt => ["ext/rcovrt/rcovrt.so"]) do |t|
+    t.libs << "ext/rcovrt"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+end
+
+file "ext/rcovrt/rcovrt.so" => FileList["ext/rcovrt/*.c"] do
+  ruby "setup.rb config"
+  ruby "setup.rb setup"
+end
+
+desc "Run the unit tests in pure-Ruby mode ."
+Rake::TestTask.new(:test_pure_ruby) do |t|
+  t.libs << "ext/rcovrt"
+  t.test_files = FileList['test/turn_off_rcovrt.rb', 'test/*_test.rb']
+  t.verbose = true
+end
+
+desc "Run the unit tests"
+task :test => [:test_rcovrt]
+#, :test_pure_ruby] disabled since 1.8.5 broke them
+
+desc "Generate rdoc documentation for the rcov library"
+Rake::RDocTask.new("rdoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "rcov"
+  rdoc.options << "--line-numbers" << "--inline-source"
+  rdoc.rdoc_files.include('README.API')
+  rdoc.rdoc_files.include('README.rake')
+  rdoc.rdoc_files.include('README.rant')
+  rdoc.rdoc_files.include('README.vim')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}
+
+task :default => :test
+
+desc "install by setup.rb"
+task :install do
+  sh "sudo ruby setup.rb install"
+end
+
+
+PKG_FILES = ["bin/rcov", "lib/rcov.rb", "lib/rcov/lowlevel.rb", "lib/rcov/xx.rb", "lib/rcov/version.rb", "lib/rcov/rant.rb", "lib/rcov/report.rb", "lib/rcov/rcovtask.rb", "ext/rcovrt/extconf.rb", "ext/rcovrt/rcovrt.c", "ext/rcovrt/callsite.c", "LEGAL", "LICENSE", "Rakefile", "Rantfile", "README.rake", "README.rant", "README.emacs", "README.en", "README.vim", "README.API", "THANKS", "test/functional_test.rb", "test/file_statistics_test.rb", "test/assets/sample_03.rb", "test/assets/sample_05-new.rb", "test/code_coverage_analyzer_test.rb", "test/assets/sample_04.rb", "test/assets/sample_02.rb", "test/assets/sample_05-old.rb", "test/assets/sample_01.rb", "test/turn_off_rcovrt.rb", "test/call_site_analyzer_test.rb", "test/assets/sample_05.rb", "rcov.vim", "rcov.el", "setup.rb", "BLURB", "CHANGES"]
+
+# gem management tasks  Use these to build the java code before creating the gem package
+# this code can also be used to generate the MRI gem.  But I left the gemspec file in too.
+spec = Gem::Specification.new do |s|
+  s.name = %q{rcov}
+  s.version = "0.8.1.3.0"
+
+  s.required_rubygems_version = nil if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mauricio Fernandez"]
+  s.cert_chain = nil
+  s.date = %q{2007-11-21}
+  s.default_executable = %q{rcov}
+  s.description = %q{rcov is a code coverage tool for Ruby. It is commonly used for viewing overall test unit coverage of target code.  It features fast execution (20-300 times faster than previous tools), multiple analysis modes, XHTML and several kinds of text reports, easy automation with Rake via a RcovTask, fairly accurate coverage information through code linkage inference using simple heuristics, colorblind-friendliness...}
+  s.email = %q{mfp@acm.org}
+  s.executables = ["rcov"]
+  s.extensions = ["ext/rcovrt/extconf.rb"]
+  s.platform = Gem::Platform::RUBY
+  s.extra_rdoc_files = ["README.API", "README.rake", "README.rant", "README.vim"]
+  s.files = PKG_FILES
+  s.has_rdoc = true
+  s.homepage = %q{http://eigenclass.org/hiki.rb?rcov}
+  s.rdoc_options = ["--main", "README.API", "--title", "rcov code coverage tool"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new("> 0.0.0")
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Code coverage analysis tool for Ruby}
+  s.test_files = ["test/functional_test.rb", "test/file_statistics_test.rb", "test/code_coverage_analyzer_test.rb", "test/call_site_analyzer_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 1
+
+    if current_version >= 3 then
+    else
+    end
+  else
+  end
+end
+
+#tasks added in to support generating the JRuby gem.
+if RUBY_PLATFORM == 'java'
+  spec.platform = "jruby"
+  spec.extensions = []
+  #add the jruby extension to the file list
+  PKG_FILES << "lib/rcovrt.jar"  
+  
+  def java_classpath_arg
+    begin
+      require 'java'
+      classpath = java.lang.System.getProperty('java.class.path')
+    rescue LoadError
+    end
+  
+    if classpath.empty?
+      classpath = FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
+    end
+  
+    classpath ? "-cp #{classpath}" : ""
+  end
+  
+  
+  CLEAN.include ["ext/java/classes", "lib/rcovrt.jar", "pkg"]
+  
+  def compile_java
+    mkdir_p "ext/java/classes"
+    sh "javac -g -target 1.5 -source 1.5 -d ext/java/classes #{java_classpath_arg} #{FileList['ext/java/src/**/*.java'].join(' ')}"
+  end
+  
+  def make_jar
+    require 'fileutils'
+    lib = File.join(File.dirname(__FILE__), 'lib')
+    FileUtils.mkdir(lib) unless File.exists? lib
+    sh "jar cf lib/rcovrt.jar -C ext/java/classes/ ." 
+  end
+  
+  file 'lib/rcovrt.jar' => FileList["ext/java/src/*.java"] do
+    compile_java
+    make_jar
+  end
+  
+  desc "compile the java extension and put it into the lib directory"
+  task :java_compile => ["lib/rcovrt.jar"]
+  
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec  
+end
+
+#extend the gem task to include the java_compile
+if RUBY_PLATFORM == 'java'
+  Rake::Task["pkg"].enhance(["java_compile"])
+end
+
+# vim: set sw=2 ft=ruby: