simplecov 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,24 @@
+.rvmrc
+.bundle
+
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Christoph Olszowka
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,43 @@
+= 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).
+
+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!
+
+Thanks to Aaron Patterson (http://engineering.attinteractive.com/2010/08/code-coverage-in-ruby-1-9/) for the original idea
+for this!
+
+== Example config for Rails 3 (using HTML formatter)
+
+Update your Gemfile with this and do a bundle install:
+  group :test do
+    gem 'simplecov', '>= 0.2.0'
+    gem 'simplecov-html', '>= 0.2.0'
+  end
+
+Then, add the following to your Rails test/test_helper.rb (right at the top, line 00):
+
+  require 'simple_cov'
+  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.
+
+== TODO
+* Improve on tests (integration tests)
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Christoph Olszowka. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "simplecov"
+    gem.summary = %Q{Code coverage for Ruby 1.9}
+    gem.description = %Q{Code coverage for Ruby 1.9}
+    gem.email = "christoph at olszowka.de"
+    gem.homepage = "http://github.com/colszowka/simplecov"
+    gem.authors = ["Christoph Olszowka"]
+    gem.add_development_dependency "shoulda", "= 2.10.3"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  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
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simplecov #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/simplecov.rb

@@ -0,0 +1,107 @@
+module SimpleCov
+  class CoverageDataError < StandardError; end;
+  VERSION = File.read(File.join(File.dirname(__FILE__), '../VERSION'))
+  
+  class << self
+    attr_accessor :running, :result # TODO: Remove result?
+    
+    #
+    # Sets up SimpleCov to run against your project.
+    #
+    # TODO: Explain config! Add default adapters!
+    #
+    def start(adapter=nil, &block)
+      unless "1.9".respond_to?(:encoding)
+        warn "WARNING: SimpleCov is activated, but you're not running Ruby 1.9 - no coverage analysis will happen"
+        return false
+      end
+      require 'coverage'
+      load_adapter(adapter) unless adapter.nil?
+      Coverage.start
+      configure(&block) if block_given?
+      @result = nil
+      self.running = true
+    end
+    
+    #
+    # Returns the result for the currntly runnig coverage run
+    #
+    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
+      if use_merging
+        SimpleCov::ResultMerger.store_result(@result) if @result
+        return SimpleCov::ResultMerger.merged_result
+      else
+        return @result
+      end
+    ensure
+      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
+    #
+    def filtered(files)
+      result = files.clone
+      filters.each do |filter|
+        result = result.select {|source_file| filter.passes?(source_file) }
+      end
+      result
+    end
+    
+    #
+    # Applies the configured groups to the given array of SimpleCov::SourceFile items
+    #
+    def grouped(files)
+      grouped = {}
+      grouped_files = []
+      groups.each do |name, filter|
+        grouped[name] = files.select {|source_file| !filter.passes?(source_file)}
+        grouped_files += grouped[name]
+      end
+      if groups.length > 0 and (other_files = files.reject {|source_file| grouped_files.include?(source_file)}).length > 0
+        grouped["Ungrouped"] = other_files
+      end
+      grouped
+    end
+    
+    # 
+    # Applies the adapter of given name on SimpleCov configuration
+    #
+    def load_adapter(name)
+      adapters.load(name)
+    end
+  end
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
+require 'simplecov/configuration'
+SimpleCov.send :extend, SimpleCov::Configuration
+require 'simplecov/adapters'
+require 'simplecov/source_file'
+require 'simplecov/result'
+require 'simplecov/filter'
+require 'simplecov/formatter'
+require 'simplecov/merge_helpers'
+require 'simplecov/result_merger'
+
+# Default configuration
+SimpleCov.configure do
+  formatter SimpleCov::Formatter::SimpleFormatter
+  # Exclude files outside of SimpleCov.root
+  load_adapter 'root_filter'
+end
+
+at_exit do
+  SimpleCov.at_exit.call
+end

data/lib/simplecov/adapters.rb

@@ -0,0 +1,47 @@
+#
+# 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
+#
+class SimpleCov::Adapters < Hash
+  # 
+  # Define a SimpleCov adapter:
+  #   SimpleCov.adapters.define 'rails' do
+  #     # Same as SimpleCov.configure do .. here
+  #   end
+  #
+  def define(name, &blk)
+    name = name.to_sym
+    raise "SimpleCov Adapter '#{name}' is already defined" unless self[name].nil?
+    self[name] = blk
+  end
+  
+  #
+  # Applies the adapter of given name
+  #
+  def load(name)
+    name = name.to_sym
+    raise "Could not find SimpleCov Adapter called '#{name}'" unless has_key?(name)
+    SimpleCov.configure(&self[name])
+  end
+end
+
+SimpleCov.adapters.define 'root_filter' do
+  # Exclude all files outside of simplecov root
+  add_filter do |src|
+    !(src.filename =~ /^#{SimpleCov.root}/)
+  end
+end
+
+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

data/lib/simplecov/configuration.rb

@@ -0,0 +1,174 @@
+#
+# Bundles the configuration options used for SimpleCov. All methods
+# defined here are usable from SimpleCov directly. Please check out
+# SimpleCov documentation for further info.
+#
+module SimpleCov::Configuration
+  attr_writer :filters, :groups, :formatter
+  
+  #
+  # The root for the project. This defaults to the
+  # current working directory.
+  #
+  # Configure with SimpleCov.root('/my/project/path')
+  #
+  def root(root=nil)
+    return @root if @root and root.nil?
+    @root = File.expand_path(root || Dir.getwd)
+  end
+  
+  #
+  # The name of the output and cache directory. Defaults to 'coverage'
+  #
+  # Configure with SimpleCov.coverage_dir('cov')
+  #
+  def coverage_dir(dir=nil)
+    return @coverage_dir if @coverage_dir and dir.nil?
+    @coverage_dir = (dir || 'coverage')
+  end
+  
+  #
+  # Returns the full path to the output directory using SimpleCov.root
+  # and SimpleCov.coverage_dir, so you can adjust this by configuring those
+  # values. Will create the directory if it's missing
+  #
+  def coverage_path
+    coverage_path = File.join(root, coverage_dir)
+    system "mkdir -p '#{coverage_path}'"
+    coverage_path
+  end
+  
+  # 
+  # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
+  #
+  def filters
+    @filters ||= []
+  end
+  
+  # The name of the command currently running. It is used for result merging and defaults 
+  # to the command line arguments the current test suite is running on.
+  # You can specify it manually with SimpleCov.command_name("test:units")
+  def command_name(name=nil)
+    @name ||= (name.nil? ? ARGV.join(" ") : name)
+  end
+  
+  #
+  # Gets or sets the configured formatter.
+  #
+  # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
+  #
+  def formatter(formatter=nil)
+    return @formatter if @formatter and formatter.nil?
+    @formatter = formatter
+    raise "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
+    @formatter
+  end
+  
+  #
+  # Returns the configured groups. Add groups using SimpleCov.add_group
+  #
+  def groups
+    @groups ||= {}
+  end
+  
+  #
+  # Returns the hash of available adapters
+  #
+  def adapters
+    @adapters ||= SimpleCov::Adapters.new
+  end
+  
+  #
+  # Configure SimpleCov using a block:
+  #
+  # 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.
+  #
+  def configure(&block)
+    instance_exec(&block)
+  end
+  
+  #
+  # Gets or sets the behavior to process coverage results.
+  #
+  # By default, it will call SimpleCov.result.format!
+  #
+  # Configure with:
+  #   SimpleCov.at_exit do
+  #     puts "Coverage done"
+  #     SimpleCov.result.format!
+  #   end
+  #
+  def at_exit(&block)
+    return Proc.new {} unless running or block_given?
+    @at_exit = block if block_given?
+    @at_exit ||= Proc.new { SimpleCov.result.format! }
+  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
+  #
+  def use_merging(use=nil)
+    @use_merging = use unless use.nil? # Set if param given
+    @use_merging = true if @use_merging != false
+  end
+  
+  #
+  # Defines them maximum age (in seconds) of a resultset to still be included in merged results.
+  # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is 
+  # more seconds ago than specified here, it won't be taken into account when merging (and is also
+  # purged from the resultset cache)
+  #
+  # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
+  #
+  # Default is 600 seconds (10 minutes)
+  #
+  # Configure with SimpleCov.merge_timeout(3600) # 1hr
+  #
+  def merge_timeout(seconds=nil)
+    @merge_timeout = seconds if !seconds.nil? and seconds.kind_of?(Fixnum)
+    @merge_timeout ||= 600
+  end
+  
+  #
+  # Add a filter to the processing chain.
+  # There are three ways to define a filter:
+  # 
+  # * as a String that will then be matched against all source files' file paths,
+  #   SimpleCov.add_filter 'app/models' # will reject all your models
+  # * as a block which will be passed the source file in question and should either
+  #   return a true or false value, depending on whether the file should be removed
+  #   SimpleCov.add_filter do |src_file|
+  #     File.basename(src_file.filename) == 'environment.rb'
+  #   end # Will exclude environment.rb files from the results
+  # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
+  #   on how to define your own filter classes
+  #
+  def add_filter(filter_argument=nil, &filter_proc)
+    filters << parse_filter(filter_argument, &filter_proc)
+  end
+  
+  def add_group(group_name, filter_argument=nil, &filter_proc)
+    groups[group_name] = parse_filter(filter_argument, &filter_proc)
+  end
+  
+  #
+  # The actal filter processor. Not meant for direct use
+  #
+  def parse_filter(filter_argument=nil, &filter_proc)
+    if filter_argument.kind_of?(SimpleCov::Filter)
+      filter_argument
+    elsif filter_argument.kind_of?(String)
+      SimpleCov::StringFilter.new(filter_argument)
+    elsif filter_proc
+      SimpleCov::BlockFilter.new(filter_proc)
+    else
+      raise ArgumentError, "Please specify either a string or a block to filter with"
+    end      
+  end
+end