r19cov 0.1.0

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 orepuri
+
+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 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/ChangeLog

@@ -0,0 +1,3 @@
+=== 0.1 (2009-12-21)
+
+* first release

data/README.rdoc

@@ -0,0 +1,15 @@
+= R19Cov: Coverage Tool for Ruby 1.9
+
+R19Cov is a simple coverage tool for Ruby 1.9.
+
+* R19Cov supports only C0 Coverage.
+* R19Cov works only with Ruby 1.9 because uses coverage library embedded in Ruby 1.9.
+
+= Install
+
+  gem sources -a http://gemcutter.org/
+  gem install r19cov
+
+= Usage
+
+  r19cov <ruby script>

data/Rakefile

@@ -0,0 +1,73 @@
+# Rake file for R19Cov. -*-ruby-*-
+# -*- encoding: utf-8 -*-
+
+require 'rake/gempackagetask'
+require File.join(File.dirname(__FILE__), 'lib', 'r19cov')
+
+spec = Gem::Specification.new do |s|
+  s.name    = 'r19cov'
+  s.version = R19Cov::VERSION
+  s.description = 'Coverage Tool for Ruby 1.9'
+  s.date     = Date.today
+  s.authors  = ['orepuri']
+  s.email    = 'orepuri@gmail.com'
+  s.homepage = 'http://github.com/orepuri'
+  s.require_paths    = ['lib']
+  s.rubygems_version = Gem::VERSION
+  s.summary = <<-SUMMARY
+R19Cov is a Coverage Tool for Ruby 1.9. It uses `coverage` library embeded in Ruby 1.9.
+R19Cov analyzes source code coverage and report in HTML format.
+SUMMARY
+  s.rubyforge_project = 'r19cov'
+  s.files = %w(COPYING ChangeLog README.rdoc Rakefile) + Dir["{lib,bin,spec}/**/*"]
+  s.bindir = 'bin'
+  s.executables << 'r19cov'
+  s.required_ruby_version = ">= 1.9"
+
+  s.add_development_dependency 'rspec', '1.2.9'
+end
+
+
+task :package
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+begin
+  require 'spec/rake/spectask'
+
+  spec_opts = lambda do
+    lib_dir = File.join(File.dirname(__FILE__), 'lib')
+    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
+    File.read('spec/spec.opts').split("\n")
+  end
+
+  desc 'Run specs'
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = Dir['spec/**/*_spec.rb']
+    t.spec_opts = spec_opts.call
+  end
+
+  namespace :spec do
+    desc 'Run specs with r19cov'
+    R19Cov::Rake::SpecTask.new do |t|
+      t.spec_files = Dir['spec/**/*_spec.rb']
+      t.spec_opts = spec_opts.call
+      t.spec_script = "spec"
+      t.rcov_opts = ['-x ruby-1.9.1,gems,spec']
+      t.rcov_dir = 'coverage'
+    end
+  end
+rescue LoadError => e
+  STDERR.puts e
+  STDERR.puts "gem install rspec if needs to run specs"
+end
+
+desc 'clean unneccessary files'
+task :clean do
+  (Dir['**/*~'] + Dir['**/*#']).each do |file|
+    cmd = "rm #{file}"
+    puts cmd
+    system cmd
+  end
+end

data/bin/r19cov

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift lib_dir unless $:.include?(lib_dir)
+
+require 'r19cov'
+R19Cov::CLI.execute

data/lib/r19cov.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+if RUBY_VERSION !~ /1\.9/
+  STDERR.puts 'R19Cov runs only Ruby 1.9'
+  exit(1)
+end
+
+$:.unshift File.dirname(__FILE__)
+
+require 'coverage'
+
+::Coverage.start
+
+module R19Cov
+  autoload :VERSION,       'r19cov/version'
+  autoload :Analyzer,      'r19cov/analyzer'
+  autoload :Coverage,      'r19cov/coverage'
+  autoload :OptionParser,  'r19cov/option_parser'
+  autoload :Options,       'r19cov/options'
+  autoload :ReportFactory, 'r19cov/report_factory'
+  autoload :CLI,           'r19cov/cli'
+
+  class Coverage
+    autoload :Summary, 'r19cov/coverage/summary'
+  end
+
+  module Report
+    autoload :HTML,       'r19cov/report/html'
+    class HTML
+      autoload :Page,       'r19cov/report/html/page'
+      autoload :DetailPage, 'r19cov/report/html/detail_page'
+      autoload :IndexPage,  'r19cov/report/html/index_page'
+    end
+  end
+
+  module Rake
+    autoload :SpecTask, 'r19cov/rake/spec_task'
+  end
+end

data/lib/r19cov/analyzer.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+
+module R19Cov
+  class Analyzer
+    def initialize(args)
+      parser = R19Cov::OptionParser.new
+      @options = parser.parse(args)
+      @report  = R19Cov::ReportFactory.create(options)
+    end
+
+    attr_reader :options, :coverages
+
+    def analyze
+      @coverages = []
+      @@loaded_files ||= []
+      target_files = []
+
+      targets.each do |target|
+        target = Pathname.new(target).cleanpath.to_s
+        if File.directory?(target)
+          Dir["#{target}/**/*.rb"].each do |file|
+            target_files << file if File.file?(file) && !target_files.include?(file)
+          end
+        else
+          target_files << target unless target_files.include?(target)
+        end
+      end
+      target_files.each do |target_file|
+        if to_be_loaded?(target_file)
+          begin
+            load target_file
+          rescue Exception
+            # rescue exception in library and do nothing
+          end
+          @@loaded_files << target_file
+        end
+      end
+
+      add_result
+      @@result.each do |file, cov|
+        next if to_be_excluded?(file) 
+        cov = @@result[File.expand_path(file)]
+        if cov
+          coverage = R19Cov::Coverage.new(file, cov)
+          @coverages << coverage
+        end
+      end
+    end
+
+    def add_result
+      @@result ||= {}
+      ::Coverage.result.each do |file, coverage|
+        coverage.each_with_index do |c, idx|
+          @@result[file] ||= []
+          if @@result[file][idx].nil?
+            @@result[file][idx] = c
+          else
+            @@result[file][idx] += c
+          end
+        end
+      end
+      ::Coverage.start
+    end
+
+    def to_be_loaded?(file)
+      !@@loaded_files.include?(file) && File.exist?(file)
+    end
+
+    def to_be_excluded?(file)
+      options.exclude.each do |e|
+        return true if file =~ /#{e}/
+      end
+      return false
+    end
+
+    def output_dir
+      options.output_dir
+    end
+
+    def output
+      @report.output(coverages)
+    end
+
+    def targets
+      options.targets
+    end
+  end
+end

data/lib/r19cov/cli.rb

@@ -0,0 +1,9 @@
+module R19Cov
+  class CLI
+    def self.execute(args = ARGV)
+      analyzer = Analyzer.new(args)
+      analyzer.analyze
+      analyzer.output
+    end
+  end
+end

data/lib/r19cov/coverage.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+module R19Cov
+  class Coverage
+    def initialize(source_file, result)
+      @filename = source_file
+      @result = result
+      load_source_file(source_file)
+    end
+
+    attr_accessor :filename, :lines, :result
+
+    def load_source_file(source_file)
+      @lines = File.read(source_file).split("\n")
+    end
+
+    def total_lines
+      lines.size
+    end
+
+    def lines_of_code
+      result.select{ |c| !c.nil? }.size
+    end
+
+    def total_coverage
+      total_lines > 0 ? (total_lines.to_f - uncovered.to_f) / total_lines.to_f : 0.0
+    end
+
+    def code_coverage
+      lines_of_code > 0 ? covered.to_f / lines_of_code.to_f : 0.0
+    end
+
+    def uncovered
+      result.select{ |c| c == 0 }.size
+    end
+
+    def covered
+      result.select{ |c| !c.nil? && c > 0 }.size
+    end
+  end
+end

data/lib/r19cov/coverage/summary.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+module R19Cov
+  class Coverage
+    class Summary
+      def initialize(coverages)
+        @coverages = coverages
+      end
+
+      attr_reader :coverages, :code_coverage
+
+      def filename
+        'index'
+      end
+
+      def total_lines
+        coverages.inject(0){ |t, c| t += c.total_lines }
+      end
+
+      def lines_of_code
+        coverages.inject(0){ |t, c| t += c.lines_of_code }
+      end
+
+      def total_coverage
+        total_lines > 0 ? (total_lines.to_f - uncovered.to_f) / total_lines.to_f : 0.0
+      end
+
+      def code_coverage
+        lines_of_code > 0 ? covered.to_f / lines_of_code.to_f : 0.0
+      end
+
+      def covered
+        coverages.inject(0){ |t, c| t += c.covered }
+      end
+
+      def uncovered
+        coverages.inject(0){ |t, c| t += c.uncovered }
+      end
+    end
+  end
+end
+

data/lib/r19cov/option_parser.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'optparse'
+
+module R19Cov
+  class OptionParser
+    def initialize(out = STDOUT, err = STDERR)
+      @out = out
+      @err = err
+    end
+
+    attr_reader :options
+
+    def parse(args)
+      @options = Options.new
+      if (idx = args.index('--'))
+        extra_args = args[idx + 1 .. -1]
+        args = args[0, idx].dup
+      else
+        extra_args = []
+        args = args.dup
+      end
+      @options.raw_options = args.dup
+      args = ['--help'] if args.empty?
+      ::OptionParser.new { |opt|
+        opt.banner = "Usage: r19cov [options] (FILE|DIRECTORY)+ [-- --extra-options]"
+        opt.on('-h', '--help', 'Show help messages') { @out.puts opt }
+        opt.on('-o', '--output [OUTPUT_DIR]', 'Specifies output directory of coverage report') { 
+          |v| @options.output_dir = v 
+        }
+        opt.on('-x', '--exclude [PATTERNS]', 'Don\'t generate info for files matching a pattern',
+               '(comma-separated regexp list)') { |v| @options.exclude = v.split(/,/) }
+        opt.on('-v', '--version', 'Show version') { @out.puts "r19cov #{R19Cov::VERSION}" }
+        opt.parse!(args)
+      }
+      @options.targets = args
+      @options.raw_options -= @options.targets
+      ARGV.replace extra_args
+      @options
+    end
+  end
+end

data/lib/r19cov/options.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require 'pathname'
+
+module R19Cov
+  class Options
+    def initialize
+      @exclude = []
+      @output_dir = default_output_dir
+      @report = default_report
+    end
+
+    attr_accessor :targets, :raw_options, :exclude, :output_dir, :report
+    
+    private
+    def default_output_dir
+      Pathname.new(File.join(Dir.pwd, 'coverage')).cleanpath.to_s
+    end
+
+    def default_report
+      :html
+    end
+  end
+end

data/lib/r19cov/rake/spec_task.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+# Define a task library for running spec with R19Cov
+
+require 'spec/rake/spectask'
+
+module R19Cov
+  module Rake
+    
+    # A Rake task that runs coverage.
+    #
+    # Example:
+    #
+    #  R19Cov::Rake::Task.new do |t|
+    #  end
+    #
+    # This will create a task that can be run with:
+    #
+    #  rake r19cov
+    #
+    class SpecTask < ::Spec::Rake::SpecTask
+      def initialize(name = :r19cov)
+        super
+      end
+      attr_accessor :spec_script
+
+      def define # :nodoc:
+        rcov = true
+        lib_path = libs.join(File::PATH_SEPARATOR)
+        task name do
+          RakeFileUtils.verbose(verbose) do
+            unless spec_file_list.empty?
+              # ruby [ruby_opts] -Ilib -S r19cov [r19cov_opts] bin/spec -- examples [spec_opts]
+              cmd_parts = [ruby_cmd || RUBY]
+              cmd_parts += ruby_opts
+              cmd_parts << %[-I"#{lib_path}"]
+              cmd_parts << "-S r19cov"
+              cmd_parts << "-w" if warning
+              cmd_parts << rcov_option_list if rcov
+              cmd_parts << %[-o "#{rcov_dir}"] if rcov
+              cmd_parts << %["#{spec_script}"]
+              cmd_parts << "--"
+              cmd_parts += spec_file_list.collect { |fn| %["#{fn}"] }
+              cmd_parts << spec_option_list
+              if out
+                cmd_parts << %[> "#{out}"]
+                STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead."
+              end
+              cmd = cmd_parts.join(" ")
+              puts cmd if verbose
+              unless system(cmd)
+                STDERR.puts failure_message if failure_message
+                raise("Command #{cmd} failed") if fail_on_error
+              end
+            end
+          end
+        end
+        self
+      end
+
+      def rcov_option_list # :nodoc:
+        ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
+      end
+    end
+  end
+end