simplecov 0.3.0 → 0.3.1

data/README.rdoc

@@ -1,30 +1,257 @@
 = simplecov
 
-SimpleCov is a code coverage analysis tool for Ruby 1.9. It makes use of Ruby's built-in Coverage library, wrapping
-it's results in a object-oriented manner. It also adds some sugar like filtering (so the coverage of used gems is not
-taken into account) and grouping (to check coverage on your Rails models for instance).
+SimpleCov is a code coverage analysis tool for Ruby 1.9. It uses 1.9's built-in Coverage library to gather code
+coverage data, but makes processing it's results much easier by providing a clean API to filter, group, merge, format
+and display those results, thus giving you a complete code coverage suite with just a couple lines of code.
 
-Though it ships with a basic formatter, it isn't particularily useful by itself, so you're going to need a dedicated
-formatter library - check out simple_cov-html for that!
+In most cases, you'll want overall coverage results for your projects, including all types of tests, cucumber features
+etc. Simplecov automatically takes care of this by caching and then merging results when generating reports, so your
+coverage report gives you a more accurate report on the blank spots in your test coverage.
 
-Thanks to Aaron Patterson (http://engineering.attinteractive.com/2010/08/code-coverage-in-ruby-1-9/) for the original idea
-for this!
+Though a very simple formatter for printing the coverage results comes bundled with the simplecov gem, this is more
+for explaining the basic usage of formatters if you want to build your own. To get a pretty HTML-page with your results, 
+you will want to use the simplecov-html gem (http://github.com/colszowka/simplecov-html).
 
-== Example config for Rails 3 (using HTML formatter)
+== Basic usage
 
 Update your Gemfile with this and do a bundle install:
   group :test do
-    gem 'simplecov', '>= 0.2.0'
-    gem 'simplecov-html', '>= 0.2.0'
+    gem 'simplecov-html', '>= 0.3.0' # Will install simplecov as a dependency
   end
 
 Then, add the following to your Rails test/test_helper.rb (right at the top, line 00):
 
-  require 'simple_cov'
+  require 'simplecov-html'
   SimpleCov.start 'rails'
 
 Now, when running rake test you'll get a coverage/ folder inside your app's root where you can browse your code coverage.
 
+== Configuration
+
+Configuration settings can be applied in three formats.
+
+The 'direct' way:
+
+  SimpleCov.some_config_option 'foo'
+  
+Using a block:
+
+  SimpleCov.configure do
+    some_config_option 'foo'
+  end
+
+Using a block and automatically starting the coverage:
+
+  SimpleCov.start do
+    some_config_option 'foo'
+  end
+  
+Most times, you'll want to use the latter, so loading and setting up simplecov is in one place at the top of your test helper.
+
+== Filters
+
+Filters can be used to remove selected files from your coverage data. By default, a filter is applied that removes all files
+OUTSIDE of your project's root directory - otherwise you'd end up with a billion of coverage reports for source files in the
+gems you are using.
+
+Of course you can define your own to remove things like configuration files, tests or whatever you don't need in your coverage
+report. 
+
+=== Defining custom filters
+
+You can currently define a filter using either a String (that will then be Regexp-matched against each source file's path),
+a block or by passing in your own Filter class.
+
+==== String filter
+  
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+  
+This simple string filter will remove all files that match "/test/" in their path.
+  
+==== Block filter
+
+  SimpleCov.start do
+    add_filter do |source_file|
+      source_file.lines.count < 5
+    end
+  end
+  
+Block filters receive a SimpleCov::SourceFile instance and expect your block to return either true (if the file is to be removed
+from the result) or false (if the result should be kept). Please check out the RDoc for SimpleCov::SourceFile to learn about the
+methods available to you. In the above example, the filter will remove all files that have less then 5 lines of code.
+  
+==== Custom filter class
+
+  class LineFilter < SimpleCov::Filter
+    def passes?(source_file)
+      source_file.lines.count < filter_argument
+    end
+  end
+  
+  SimpleCov.add_filter LineFilter.new(5)
+  
+Defining your own filters is pretty easy: Just inherit from SimpleCov::Filter and define a method 'passes?(source_file)'. When running
+the filter, a true return value from this method will result in the removal of the given source_file. The filter_argument method
+is being set in the SimpleCov::Filter initialize method and thus is set to 5 in this example.
+
+== Groups
+
+You can separate your source files into groups. For example, in a rails app, you'll want to have separate listings for
+Models, Controllers, Helpers, Libs and Plugins. Group definition works similar to Filters (and indeed also accepts custom
+filter classes), but source files end up in a group when the filter passes (returns true), as opposed to filtering results,
+which exclude files from results when the filter results in a true value.
+
+Add your groups with:
+
+  SimpleCov.start do
+    add_group "Models", "app/models"
+    add_group "Controllers", "app/controllers"
+    add_group "Long files" do |src_file|
+      src_file.lines.count > 100
+    end
+    add_group "Short files", LineFilter.new(5) # Using the LineFilter class defined in Filters section above
+  end
+
+== Merging results
+
+Normally, you want to have your coverage analyzed across ALL of your test suites, right?
+
+Simplecov automatically caches coverage results in your (coverage_path)/resultset.yml. Those results will then
+be automatically merged when generating the result, so when coverage is set up properly for cucumber and your
+unit / functional / integration tests, all of those test suites will be taken into account when building the
+coverage report.
+
+There are two things to note here though:
+
+=== Test suite names
+
+First, simplecov by itself does not really know about "test suites" and thus makes a guess based upon the command
+line arguments it is currently running on. This works fine, though the test suites used for your coverage report
+won't be easy to recognize. 
+
+Thus, if you want nicely labeled test suites, you have to give Simplecov a cue what the name of the currently running
+test suite is. You can do so by specifying SimpleCov.command_name in one test file that is part of your specific suite.
+
+So, in order to get proper suite names in a Rails app (yeah, sorry for being Rails biased, but everyone knows what
+the structure of those projects is. You can apply this accordingly to the RSpecs for your Outlook-WebDAV-Calendar-Sync gem), 
+you could do something like this:
+
+  # test/unit/some_test.rb
+  SimpleCov.command_name 'Unit Tests'
+  
+  # test/functionals/some_controller_test.rb
+  SimpleCov.command_name "Functional Tests"
+  
+  # test/integration/some_integration_test.rb
+  SimpleCov.command_name "Integration Tests"
+  
+  # features/steps/web_steps.rb
+  SimpleCov.command_name "Cucumber Features"
+  
+Note that this has only to be invoked ONCE PER TEST SUITE, so even if you have 200 unit test files, specifying it in 
+some_test.rb is fair enough.
+
+simplecov-html prints the used test suites in the footer of the generated coverage report.
+
+=== Timeout for merge
+
+Of course, your cached coverage data is likely to become invalid at some point. Thus, result sets that are older than
+SimpleCov.merge_timeout will not be used any more. By default, the timeout is 600 seconds (10 minutes), and you can
+raise (or lower) it by specifying SimpleCov.merge_timeout 3600 (1 hour), or, inside a configure/start block, with
+just "merge_timeout 3600".
+
+You can deactivate merging altogether with "SimpleCov.use_merging false".
+
+== Adapters
+
+By default, Simplecov's only config assumption is that you only want coverage reports for files inside your project
+root. To save you from repetitive configuration, you can use predefined blocks of configuration, called 'adapters',
+or define your own. 
+
+You can then pass the name of the adapter to be used as the first argument to SimpleCov.start. For example, simplecov 
+comes bundled with a 'rails' adapter. It looks somewhat like this:
+
+  SimpleCov.adapters.define 'rails' do
+    add_filter '/test/'
+    add_filter '/config/'
+  
+    add_group 'Controllers', 'app/controllers'
+    add_group 'Models', 'app/models'
+    add_group 'Helpers', 'app/helpers'
+    add_group 'Libraries', 'lib'
+    add_group 'Plugins', 'vendor/plugins'
+  end
+  
+As you can see, it's just a glorified SimpleCov.configure block. In your test_helper.rb, launch simplecov with:
+
+  SimpleCov.start 'rails'
+  
+    OR
+
+  SimpleCov.start 'rails' do
+    # additional config here
+  end
+  
+=== Custom adapters
+
+You can load additional adapters with the SimpleCov.load_adapter('xyz') method. This allows you to build upon an existing
+adapter and customize it so you can reuse it in unit tests and cucumber features, for example.
+
+  # lib/simplecov_custom_adapter.rb
+  require 'simplecov'
+  SimpleCov.adapters.define 'myadapter' do
+    load_adapter 'rails'
+    add_filter 'vendor' # Don't include vendored stuff
+  end
+  
+  # features/support/env.rb
+  require 'simplecov_custom_adapter'
+  SimpleCov.start 'myadapter'
+  
+  # test/test_helper.rb
+  require 'simplecov_custom_adapter'
+  SimpleCov.start 'myadapter'
+  
+== Customizing exit behaviour
+
+You can define what simplecov should do when your test suite finishes by customizing the at_exit hook:
+
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+  end
+  
+Above is the default behaviour. Do whatever you like instead!
+
+== Using your own formatter
+
+You can use your own formatter with: 
+
+  SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
+
+When calling SimpleCov.result.format!, it will be invoked with SimpleCov::Formatter::YourFormatter.new.format(result), "result" 
+being an instance of SimpleCov::Result. Do whatever your wish with that!
+
+== Configuration options
+
+=== SimpleCov.root '/some/path/to/coverage'
+
+The root directory for the project coverage is being generated for. This defaults to the current working directory
+and should be just fine. Note that by default, all files outside of root will be filtered and thus not included in your
+coverage report, so you'll probably rarely want to adjust this setting other than specifying an absolute path here.
+
+=== SimpleCov.coverage_dir 'coverage'
+
+The name of the subdirectory of root that coverage will be generated to. Defaults to 'coverage'.
+
+=== ...TODO...
+
+== Kudos
+
+Thanks to Aaron Patterson (http://engineering.attinteractive.com/2010/08/code-coverage-in-ruby-1-9/) for the original idea
+for this!
+
 == TODO
 * Improve on tests (integration tests)
 

data/Rakefile

@@ -25,19 +25,6 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
 task :test => :check_dependencies
 
 task :default => :test

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/lib/simplecov.rb

@@ -1,14 +1,32 @@
+#
+# Code coverage for ruby 1.9. Please check out README for a full introduction.
+#
 module SimpleCov
+  # Indicates invalid coverage data
   class CoverageDataError < StandardError; end;
+  
+  # The version of the simplecov gem
   VERSION = File.read(File.join(File.dirname(__FILE__), '../VERSION'))
   
   class << self
-    attr_accessor :running, :result # TODO: Remove result?
+    attr_accessor :running#, :result # TODO: Remove result?
     
     #
     # Sets up SimpleCov to run against your project.
+    # You can optionally specify an adapter to use as well as configuration with a block:
+    #   SimpleCov.start
+    #    OR
+    #   SimpleCov.start 'rails' # using rails adapter
+    #    OR
+    #   SimpleCov.start do
+    #     add_filter 'test'
+    #   end
+    #     OR
+    #   SimpleCov.start 'rails' do
+    #     add_filter 'test'
+    #   end
     #
-    # TODO: Explain config! Add default adapters!
+    # Please check out the RDoc for SimpleCov::Configuration to find about available config options
     #
     def start(adapter=nil, &block)
       unless "1.9".respond_to?(:encoding)
@@ -24,12 +42,13 @@ module SimpleCov
     end
     
     #
-    # Returns the result for the currntly runnig coverage run
+    # Returns the result for the current coverage run, merging it across test suites
+    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
     #
     def result
       @result ||= SimpleCov::Result.new(Coverage.result) if running
       # If we're using merging of results, store the current result
-      # first, then merge the results and return them
+      # first, then merge the results and return those
       if use_merging
         SimpleCov::ResultMerger.store_result(@result) if @result
         return SimpleCov::ResultMerger.merged_result
@@ -40,14 +59,6 @@ module SimpleCov
       self.running = false
     end
     
-    #
-    # Returns the project name - currently assuming the last dirname in
-    # the SimpleCov.root is this
-    #
-    def project_name
-      File.basename(root.split('/').last).capitalize.gsub('_', ' ')
-    end
-    
     #
     # Applies the configured filters to the given array of SimpleCov::SourceFile items
     #

data/lib/simplecov/adapters.rb

@@ -1,9 +1,9 @@
 #
 # Adaptars are glorified SimpleCov configuration procs that can be easily 
 # loaded using SimpleCov.start :rails and defined using
-# SimpleCov.adapters.define :foo do
-#   # SimpleCov configuration here, same as in 
-# end
+#   SimpleCov.adapters.define :foo do
+#     # SimpleCov configuration here, same as in  SimpleCov.configure
+#   end
 #
 class SimpleCov::Adapters < Hash
   # 
@@ -19,7 +19,7 @@ class SimpleCov::Adapters < Hash
   end
   
   #
-  # Applies the adapter of given name
+  # Applies the adapter of given name on SimpleCov.configure
   #
   def load(name)
     name = name.to_sym

data/lib/simplecov/configuration.rb

@@ -79,14 +79,15 @@ module SimpleCov::Configuration
   end
   
   #
-  # Configure SimpleCov using a block:
+  # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
+  # you're calling.
   #
   # SimpleCov.configure do
   #   add_filter 'foobar'
   # end
   #
-  # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a lot of configure
-  # options.
+  # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a buchn of configure
+  # options at once.
   #
   def configure(&block)
     instance_exec(&block)
@@ -109,6 +110,16 @@ module SimpleCov::Configuration
     @at_exit ||= Proc.new { SimpleCov.result.format! }
   end
   
+  #
+  # Returns the project name - currently assuming the last dirname in
+  # the SimpleCov.root is this.
+  #
+  def project_name(new_name=nil)
+    return @project_name if @project_name and new_name.nil?
+    @project_name = new_name if new_name.kind_of?(String)
+    @project_name ||= File.basename(root.split('/').last).capitalize.gsub('_', ' ')
+  end
+  
   #
   # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
   # are joined and combined into a single coverage report
@@ -153,6 +164,11 @@ module SimpleCov::Configuration
     filters << parse_filter(filter_argument, &filter_proc)
   end
   
+  #
+  # Define a group for files. Works similar to add_filter, only that the first
+  # argument is the desired group name and files PASSING the filter end up in the group
+  # (while filters exclude when the filter is applicable).
+  #
   def add_group(group_name, filter_argument=nil, &filter_proc)
     groups[group_name] = parse_filter(filter_argument, &filter_proc)
   end

data/lib/simplecov/filter.rb

@@ -22,12 +22,16 @@ module SimpleCov
   end
   
   class StringFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # string configured when initializing this Filter with StringFilter.new('somestring)
     def passes?(source_file)
       !(source_file.filename =~ /#{filter_argument}/)
     end
   end
   
   class BlockFilter < SimpleCov::Filter
+    # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
+    # returns true for the given source file.
     def passes?(source_file)
       !filter_argument.call(source_file)
     end

data/lib/simplecov/formatter.rb

@@ -1,6 +1,6 @@
 module SimpleCov
+  # TODO: Documentation on how to build your own formatters
   module Formatter
-    
   end
 end
 

data/lib/simplecov/formatter/simple_formatter.rb

@@ -1,4 +1,8 @@
+#
+# A ridiculously simple formatter for SimpleCov results.
+#
 class SimpleCov::Formatter::SimpleFormatter
+  # Takes a SimpleCov::Result and generates a string out of it
   def format(result)
     output = ""
     result.groups.each do |name, files|

data/lib/simplecov/merge_helpers.rb

@@ -1,4 +1,5 @@
 module SimpleCov::ArrayMergeHelper
+  # Merges an array of coverage results with self
   def merge_resultset(array)
     new_array = []
     
@@ -20,6 +21,7 @@ module SimpleCov::ArrayMergeHelper
 end
 
 module SimpleCov::HashMergeHelper
+  # Merges the given Coverage.result hash with self
   def merge_resultset(hash)
     new_resultset = {}
     (self.keys + hash.keys).each do |filename|

data/lib/simplecov/result.rb

@@ -2,45 +2,63 @@ require 'digest/sha1'
 require 'yaml'
 
 module SimpleCov
+  #
+  # A simplecov code coverage result, initialized from the Hash Ruby 1.9's built-in coverage
+  # library generates (Coverage.result).
+  #
   class Result    
-    attr_reader :original_result, :files
-    attr_writer :created_at, :command_name
+    # Returns the original Coverage.result used for this instance of SimpleCov::Result
+    attr_reader :original_result
+    # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+    attr_reader :files
     alias_method :source_files, :files
+    # Explicitly set the Time this result has been created
+    attr_writer :created_at
+    # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
+    attr_writer :command_name
 
+    # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
+    # coverage data)
     def initialize(original_result)
       @original_result = original_result.freeze
       @files = original_result.map {|filename, coverage| SimpleCov::SourceFile.new(filename, coverage)}.sort_by(&:filename)
       filter!
     end
   
+    # Returns all filenames for source files contained in this result
     def filenames
       files.map(&:filename)
     end
     
+    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
     def groups
       @groups ||= SimpleCov.grouped(files)
     end
     
+    # The overall percentual coverage for this result
+    #
+    # FIXME: Kind of inaccurate - should use LOC instead of Files count!
     def covered_percent
       files.map(&:covered_percent).inject(:+) / files.count.to_f
     end
     
+    # Applies the configured SimpleCov.formatter on this result
     def format!
       SimpleCov.formatter.new.format(self)
     end
     
-    # Defines when this result has been created
+    # Defines when this result has been created. Defaults to Time.now
     def created_at
       @created_at ||= Time.now
     end
     
-    # The command name that launched this result. 
+    # The command name that launched this result.
     # Retrieved from SimpleCov.command_name
     def command_name
       @command_name ||= SimpleCov.command_name
     end
     
-    # Returns a hash representation of this Result
+    # Returns a hash representation of this Result that can be used for marshalling it into YAML
     def to_hash
       {command_name => {:original_result => original_result.reject {|filename, result| !filenames.include?(filename) }, :created_at => created_at}}
     end
@@ -66,6 +84,7 @@ module SimpleCov
     
     private
   
+    # Applies all configured SimpleCov filters on this result's source files
     def filter!
       @files = SimpleCov.filtered(files)
     end

data/lib/simplecov/result_merger.rb

@@ -1,15 +1,26 @@
 require 'yaml'
+#
+# Singleton that is responsible for caching, loading and merging
+# SimpleCov::Results into a single result for coverage analysis based
+# upon multiple test suites.
+#
 module SimpleCov::ResultMerger
   class << self
+    # The path to the resultset.yml cache file
     def resultset_path
       File.join(SimpleCov.coverage_path, 'resultset.yml')
     end
     
+    # Loads the cached resultset from YAML and returns it as a Hash
     def resultset
       return {} unless File.exist?(resultset_path)
       YAML.load(File.read(resultset_path))
     end
     
+    # Gets the resultset hash and re-creates all included instances
+    # of SimpleCov::Result from that.
+    # All results that are above the SimpleCov.merge_timeout will be
+    # dropped. Returns an array of SimpleCov::Result items.
     def results
       results = []
       resultset.each do |command_name, data| 
@@ -22,6 +33,11 @@ module SimpleCov::ResultMerger
       results
     end
     
+    #
+    # Gets all SimpleCov::Results from cache, merges them and produces a new
+    # SimpleCov::Result with merged coverage data and the command_name 
+    # for the result consisting of a join on all source result's names
+    #
     def merged_result
       merged = {}
       results.each do |result|
@@ -33,6 +49,7 @@ module SimpleCov::ResultMerger
       result
     end
     
+    # Saves the given SimpleCov::Result in the resultset cache
     def store_result(result)
       new_set = resultset
       command_name, data = result.to_hash.first

data/lib/simplecov/source_file.rb

@@ -1,4 +1,8 @@
 module SimpleCov
+  #
+  # Representation of a source file including it's coverage data, source code,
+  # source lines and featuring helpers to interpret that data.
+  #
   class SourceFile
     # Representation of a single line in a source file including
     # this specific line's source code, line_number and code coverage,
@@ -6,7 +10,12 @@ module SimpleCov
     # line), 0 (line not covered) or >1 (the amount of times the line was 
     # executed)
     class Line
-      attr_reader :src, :line_number, :coverage
+      # The source code for this line. Aliased as :source
+      attr_reader :src
+      # The line number in the source file. Aliased as :line, :number
+      attr_reader :line_number
+      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
+      attr_reader :coverage
       # Lets grab some fancy aliases, shall we?
       alias_method :source, :src
       alias_method :line, :line_number
@@ -19,48 +28,71 @@ module SimpleCov
         @src, @line_number, @coverage = src, line_number, coverage
       end
     
+      # Returns true if this is a line that should have been covered, but was not
       def missed?
         not never? and coverage == 0
       end
     
+      # Returns true if this is a line that has been covered
       def covered?
         not never? and coverage > 0
       end
     
+      # Returns true if this line is not relevant for coverage
       def never?
         coverage.nil?
       end
     end
   
-    attr_reader :filename, :coverage, :src, :lines
+    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+    attr_reader :filename
+    # The array of coverage data received from the Coverage.result
+    attr_reader :coverage
+    # The source code for this file. Aliased as :source
+    attr_reader :src
     alias_method :source, :src
-    alias_method :source_lines, :lines
   
     def initialize(filename, coverage)
       @filename, @coverage, @src = filename, coverage, File.readlines(filename)
+    end
+    
+    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+    # and thus including coverage data. Aliased as :source_lines
+    def lines
+      return @lines unless @lines.nil?
+      # Initialize lines
       @lines = []
       coverage.each_with_index do |coverage, i|
         @lines << SimpleCov::SourceFile::Line.new(src[i], i+1, coverage)
       end
+      @lines
     end
+    alias_method :source_lines, :lines
     
+    # Access SimpleCov::SourceFile::Line source lines by line number
     def line(number)
       lines[number-1]
     end
   
+    # The coverage for this file in percent. 0 if the file has no relevant lines
     def covered_percent
       return 100.0 if lines.length == 0 or lines.length == never_lines.count
       (covered_lines.count) * 100 / (lines.count-never_lines.count).to_f
     end
   
+    # Returns all covered lines as SimpleCov::SourceFile::Line
     def covered_lines
       @covered_lines ||= lines.select {|c| c.covered? }
     end
   
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
     def missed_lines
       @missed_lines ||= lines.select {|c| c.missed? }
     end
   
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
     def never_lines
       @never_lines ||= lines.select {|c| c.never? }
     end

data/simplecov.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{simplecov}
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Christoph Olszowka"]
-  s.date = %q{2010-08-22}
+  s.date = %q{2010-08-23}
   s.description = %q{Code coverage for Ruby 1.9}
   s.email = %q{christoph at olszowka.de}
   s.extra_rdoc_files = [

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Christoph Olszowka
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-22 00:00:00 +02:00
+date: 2010-08-23 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency