insurance 0.1

data/bin/railscov

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'insurance'
+rescue LoadError
+  require 'rubygems'
+  require 'insurance'
+end
+require 'optparse'
+
+options = {}
+opts = OptionParser.new do |opts|
+  opts.banner = <<-EOF
+Insurance Rails Runner #{Insurance::VERSION}, #{Insurance::RELEASE_DATE}
+Usage: railscov [options]
+EOF
+  
+  opts.separator ''
+  opts.on('-A', '--apply-to DIRECTORY',
+    'Create a Rake task for running the ',
+    'Insurance analyzer.',
+    'Currently only works with Rails apps.'
+  ) { |value| options[:apply_to] = value }
+  
+  opts.separator ''
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+  opts.on_tail('--version', 'Show version') do
+    puts "Insurance #{Insurance::VERSION}, #{Insurance::RELEASE_DATE}"
+  end
+end
+opts.parse! ARGV
+
+if options[:apply_to]
+  require 'insurance/generators/rails/loader'
+  InsuranceLoader::Generators::RailsLoader.load! options
+  exit
+end
+
+unless File.exist?('config/environment.rb')
+  puts 'Please run railscov from your RAILS_ROOT'
+  exit
+end
+
+
+# We modify Test::Unit::TestCase so that tracing is only turned on
+# when executing a test.  This avoids tracing framework loading
+# and speeds things up by a great deal.
+
+require 'test/unit'
+module Test
+  module Unit
+    include Assertions
+    class TestCase
+      def run(result)
+        yield(STARTED, name)
+        @_result = result
+        begin
+          setup
+          Insurance.set_trace_func Insurance::RailsAnalyzer.method(:line_trace_func).to_proc
+          __send__(@method_name)
+          rescue AssertionFailedError => e
+          add_failure(e.message, e.backtrace)
+        rescue StandardError, ScriptError
+          add_error($!)
+        ensure
+          Insurance.set_trace_func nil
+          begin
+          teardown
+          rescue AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue StandardError, ScriptError
+            add_error($!)
+          end
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end
+    end
+  end
+end
+
+Insurance::RailsAnalyzer.run(Dir['test/unit/*.rb'] + Dir['test/functional/*.rb'])

data/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile 'insurance_tracer'

data/insurance_tracer.c

@@ -0,0 +1,99 @@
+#include <ruby.h>
+#include <node.h>
+#include <env.h>
+
+static int tracing    = 0;
+static int am_tracing = 0;
+
+static char *
+get_event_name(rb_event_t event)
+{
+  switch (event) {
+  case RUBY_EVENT_LINE:
+	  return "line";
+  case RUBY_EVENT_CLASS:
+	  return "class";
+  case RUBY_EVENT_END:
+	  return "end";
+  case RUBY_EVENT_CALL:
+	  return "call";
+  case RUBY_EVENT_RETURN:
+	  return "return";
+  case RUBY_EVENT_C_CALL:
+	  return "c-call";
+  case RUBY_EVENT_C_RETURN:
+	  return "c-return";
+  case RUBY_EVENT_RAISE:
+	  return "raise";
+  default:
+	  return "unknown";
+  }
+}
+
+static VALUE cov_tracer = 0;
+
+static void
+insurance_trace_func(event, node, self, id, klass)
+    rb_event_t event;
+    NODE *node;
+    VALUE self;
+    ID id;
+    VALUE klass;
+{
+  int state, raised;
+  NODE *node_save;
+  VALUE srcfile;
+  struct FRAME *prev;
+  static int counting = 0;
+
+  if (tracing) return;
+  if (id == ID_ALLOCATOR) return;
+  tracing = 1;
+  if (node) {
+    ruby_current_node = node;
+    ruby_frame->node = node;
+    ruby_sourcefile = node->nd_file;
+    ruby_sourceline = nd_line(node);
+  }
+
+  srcfile = rb_str_new2(ruby_sourcefile?ruby_sourcefile:"(ruby)");
+  rb_funcall(cov_tracer, rb_intern("call"), 3, rb_str_new2(get_event_name(event)), srcfile, INT2FIX(ruby_sourceline));
+  tracing = 0;
+}
+
+static VALUE
+is_tracing()
+{
+  if (am_tracing == 0) {
+    return Qfalse;
+  }
+  return Qtrue;
+}
+
+static VALUE
+set_insurance_trace_func(obj, trace)
+    VALUE obj, trace;
+{
+  if (NIL_P(trace)) {
+	  cov_tracer = 0;
+	  am_tracing = 0;
+	  rb_remove_event_hook(insurance_trace_func);
+	  return Qnil;
+  }
+
+  cov_tracer = trace;
+  am_tracing = 1;
+  rb_add_event_hook(insurance_trace_func, RUBY_EVENT_LINE);
+  return trace;
+}
+
+
+void
+Init_insurance_tracer()
+{
+    VALUE mProf;
+
+    mProf = rb_define_module("Insurance");
+    rb_define_module_function(mProf, "set_trace_func", set_insurance_trace_func, 1);
+    rb_define_module_function(mProf, "is_tracing?", is_tracing, 0);
+}

data/lib/insurance.rb

@@ -0,0 +1,9 @@
+require 'insurance_tracer.so'
+require 'insurance/analyzer'
+require 'insurance/source_file'
+require 'insurance/formatter'
+
+module Insurance
+  VERSION      = '0.1'
+  RELEASE_DATE = '28 Oct 2005'
+end

data/lib/insurance/analyzer.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+module Insurance
+  FILELIST = {}
+  
+  END {
+    Insurance.set_trace_func nil
+    
+    Dir.mkdir('insurance') unless File.exist?('insurance')
+    
+    Insurance::Formatter.run(Insurance::FILELIST)    
+  }
+  
+  class Analyzer
+    def self.line_trace_func(event, file, line)     
+#       case event
+#       when 'c-call', 'c-return'
+#         return
+#       end
+      
+      if (full_path = self.filter(file))
+        FILELIST[full_path] ||= SourceFile.new(full_path)
+        FILELIST[full_path] << line
+      end
+    end
+    
+    def self.filter(file)
+      file
+    end
+    
+    def self.run(files)
+      Insurance.set_trace_func self.method(:line_trace_func).to_proc
+      files.each { |f| load f }
+    end
+  end
+  
+  class RailsAnalyzer < Analyzer
+    @@dir_regexp  = Regexp.new("^#{Dir.pwd}/(?:lib|app/(?:models|controllers))/")
+    @@_path_cache = {}
+    
+    def self.filter(file)
+      begin
+        full_path =  @@_path_cache[file] || (@@_path_cache[file] = File.expand_path(file))
+        if @@dir_regexp =~ full_path
+          pwd = Dir.pwd
+          return full_path[(full_path.index(pwd)+pwd.length+1)..-1]
+        else
+          return false
+        end
+      rescue
+        return false
+      end
+    end
+    
+    def self.run(files)
+      # The rails analyzer does not need to set the trace func, because that is
+      # done in the perversion of Test::Unit::TestCase.
+      
+      # Since we flip tracing on only right before a test is executed, to avoid
+      # tracing the entire framework at all times (very slow), we need to pre-load
+      # all of the application's models and controllers so that we can trace things
+      # at the class level.  This is just easier to do than to try and figure out
+      # what should really be marked as hit in the output stage.
+      
+      pipe = IO.popen('-', 'w+')
+      if pipe
+        Insurance::FILELIST.merge!(YAML::load(pipe.read))
+        files.each { |f| load f }
+      else
+        at_exit {
+          Insurance.set_trace_func nil
+          puts Insurance::FILELIST.to_yaml
+          exit!
+        }
+        
+        require 'config/environment'
+        Insurance.set_trace_func self.method(:line_trace_func).to_proc
+        require 'application'
+        (Dir['app/models/*.rb'] + Dir['app/controllers/*.rb']).each { |f| load f }
+     end
+    end
+  end  
+end

data/lib/insurance/formatter.rb

@@ -0,0 +1,42 @@
+require 'erb'
+require 'syntax'
+require 'syntax/convertors/html'
+
+module Insurance
+  class Formatter
+    include ERB::Util
+    
+    def self.run(filelist)
+      files = filelist.keys.sort
+
+      project_name    = File.basename Dir.pwd
+
+      File.open("insurance/index.html", 'w') do |f|
+        f.write ERB.new(File.read("#{File.dirname(__FILE__)}/templates/index.rhtml")).result(binding)
+        puts "Wrote insurance/index.html"
+      end
+
+      filelist.each do |file, sf|
+        sf.post_analyze!
+
+        file_under_test = sf.name
+        percentage      = sf.coverage_percent
+
+        File.open("insurance/#{sf.name.gsub('/', '-')}.html", 'w') do |f|
+          contents = File.open(sf.name, 'r').readlines
+          body = "<pre class=\"ruby\">\n"
+          contents.each_with_index do |line, num|
+            unless sf.lines.include?(num + 1)
+              body << "#{'%3s' % (num + 1).to_s}  <span class=\"unhit\">#{Syntax::Convertors::HTML.for_syntax('ruby').convert(line.chomp, false)}</span>\n"
+            else
+              body << "#{'%3s' % (num + 1).to_s}  #{Syntax::Convertors::HTML.for_syntax('ruby').convert(line, false)}"
+            end
+          end
+          body << "</pre>"
+          f.write ERB.new(File.read("#{File.dirname(__FILE__)}/templates/code-page.rhtml")).result(binding)
+          puts "Wrote insurance/#{sf.name.gsub('/', '-')}.html"
+        end
+      end
+    end
+  end
+end

data/lib/insurance/generators/rails/insurance/insurance_generator.rb

@@ -0,0 +1,12 @@
+class InsuranceGenerator < Rails::Generator::NamedBase
+  def initialize(runtime_args, runtime_options={})
+    super
+  end
+  
+  def manifest
+    record do |m|
+      m.directory 'lib/tasks'
+      m.template 'insurance.rake', File.join('lib', 'tasks', 'insurance.rake')
+    end
+  end
+end

data/lib/insurance/generators/rails/insurance/templates/insurance.rake

@@ -0,0 +1,7 @@
+desc 'Run Insurnace coverage analysis'
+task :insurance => [ :prepare_test_database ] do
+  puts
+  puts 'You may want to get a beverage while this runs.  It could take a while!'
+  puts
+  system 'railscov'
+end

data/lib/insurance/generators/rails/loader.rb

@@ -0,0 +1,17 @@
+module InsuranceLoader
+  module Generators
+    class RailsLoader
+      def self.load!(options)
+        require "#{options[:apply_to]}/config/environment"
+        require "rails_generator"
+        require "rails_generator/scripts/generate"
+
+        Rails::Generator::Base.sources << Rails::Generator::PathSource.new(
+          :insurance, File.dirname(__FILE__))
+
+        args = ['insurance', 'insurance', 'insurance']
+        Rails::Generator::Scripts::Generate.new.run(args)
+      end
+    end
+  end
+end

data/lib/insurance/source_file.rb

@@ -0,0 +1,35 @@
+module Insurance
+  class SourceFile
+    attr_reader :name
+    attr_reader :lines
+    attr_reader :coverage_percent
+    
+    def initialize(name)
+      @name             = name
+      @lines            = []
+      @coverage_percent = 0
+    end
+    
+    def <<(line)
+      @lines << line unless @lines.include?(line)
+    end
+    
+    # This marks crufty crap that isn't important, like 'end', and whitespace.
+    def post_analyze!
+      contents = File.open(self.name, 'r').readlines
+      contents.each_with_index do |line, num|
+        sline = line.strip
+        lines << num + 1 if sline.empty?
+        lines << num + 1 if sline =~ /^#/
+        lines << num + 1 if sline =~ /^\s*(?:end|\})\s*(?:#.*)?$/
+        lines << num + 1 if sline =~ /^(public|private|protected)/
+        lines << num + 1 if sline =~ /^(?:begin\s*(?:#.*)?|ensure\s*(?:#.*)?|else\s*(?:#.*)?)$/
+        lines << num + 1 if sline =~ /^(?:rescue)/
+        lines << num + 1 if sline =~ /^case\s*(?:#.*)?$/
+        lines << num + 1 if sline =~ /^(\)|\]|\})(?:#.*)?$/
+      end
+      
+      @coverage_percent = (@lines.size.to_f / contents.size.to_f) * 100.0
+    end
+  end
+end

data/lib/insurance/templates/code-page.rhtml

@@ -0,0 +1,73 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title><%= file_under_test %></title>
+    <style type="text/css" media="screen">
+    /* <![CDATA[ */
+      body {
+        font-size: small;
+      }
+      
+      th { text-align: left; }
+      
+      .ruby .normal    {}
+      .ruby .comment   { color: #bfbfbf; }
+      .ruby .keyword   { color: #FF5600; font-weight: bold; }
+      .ruby .method    { color: #21439C; }
+      .ruby .class     { color: #21439C; }
+      .ruby .module    { color: #21439C; }
+      .ruby .punct     { color: #21439C; font-weight: bold; }
+      .ruby .symbol    { color: #21439C; }
+      .ruby .string    { color: #00A33F; }
+      .ruby .char      { color: #00A33F; }
+      .ruby .ident     { color: #21439C; }
+      .ruby .constant  { color: #A535AE; }
+      .ruby .regex     { color: #990000; }
+      .ruby .number    { }
+      .ruby .attribute { }
+      .ruby .global    { }
+      .ruby .expr      { }
+      
+      .unhit { background: #FFC6C6; }
+      
+      .right { text-align: right; }
+      
+      #code-tree {
+        float: left;
+        width: 30%;
+      }
+
+      #graph, #code {
+        margin-left: 30%;
+      }
+
+      #graph {
+        padding-left: 35px;
+        }
+
+    /* ]]> */
+    </style>
+    
+  </head>
+  <body>
+    <div id="header">
+      <h1>Insurance - <%= project_name %></h1>
+    </div>
+    <div id="code-tree">
+      <table>
+        <% files.each do |f| %>
+          <tr>
+            <td><a href="<%= "#{f.gsub('/', '-')}.html" %>"><%= f %></a></td>
+            <td></td>
+          </tr>
+        <% end %>
+      </table>
+    </div>
+    <div id="code">
+      <h2><%= file_under_test %></h2>
+      <%= body %>
+    </div>
+  </body>
+</html>

data/lib/insurance/templates/index.rhtml

@@ -0,0 +1,72 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title>Insurance - <%= project_name %></title>
+    <style type="text/css" media="screen">
+    /* <![CDATA[ */
+      body {
+        font-size: small;
+      }
+      
+      th { text-align: left; }
+      
+      .ruby .normal    {}
+      .ruby .comment   { color: #bfbfbf; }
+      .ruby .keyword   { color: #FF5600; font-weight: bold; }
+      .ruby .method    { color: #21439C; }
+      .ruby .class     { color: #21439C; }
+      .ruby .module    { color: #21439C; }
+      .ruby .punct     { color: #21439C; font-weight: bold; }
+      .ruby .symbol    { color: #21439C; }
+      .ruby .string    { color: #00A33F; }
+      .ruby .char      { color: #00A33F; }
+      .ruby .ident     { color: #21439C; }
+      .ruby .constant  { color: #A535AE; }
+      .ruby .regex     { color: #990000; }
+      .ruby .number    { }
+      .ruby .attribute { }
+      .ruby .global    { }
+      .ruby .expr      { }
+      
+      .unhit { background: #FFC6C6; }
+      
+      .right { text-align: right; }
+      
+      #code-tree {
+        float: left;
+        width: 30%;
+      }
+
+      #graph, #code {
+        margin-left: 30%;
+      }
+
+      #graph {
+        padding-left: 35px;
+        }
+
+    /* ]]> */
+    </style>
+    
+  </head>
+  <body>
+    <div id="header">
+      <h1>Insurance - <%= project_name %></h1>
+    </div>
+    <div id="code-tree">
+      <table>
+        <% files.each do |f| %>
+          <tr>
+            <td><a href="<%= "#{f.gsub('/', '-')}.html" %>"><%= f %></a></td>
+            <td></td>
+          </tr>
+        <% end %>
+      </table>
+    </div>
+    <div id="code">
+    The next release will have much more information here.  I promise!
+    </div>
+  </body>
+</html>

data/test/test_settracefunc.rb

@@ -0,0 +1,140 @@
+# Taken from Ruby 1.8.3's test_settracefunc.rb
+require 'test/unit'
+require 'insurance'
+
+class TestSetTraceFunc < Test::Unit::TestCase
+  def foo; end;
+
+  def bar
+    events = []
+    Insurance.set_trace_func(Proc.new { |event, file, lineno|
+      events << [event, lineno]
+    })
+    return events
+  end
+
+  def test_event
+    events = []
+    Insurance.set_trace_func(Proc.new { |event, file, lineno|
+      events << [event, lineno]
+    })
+    a = 1
+    foo
+    a
+    b = 1 + 2
+    if b == 3
+      case b
+      when 2
+        c = "b == 2"
+      when 3
+        c = "b == 3"
+      end
+    end
+    begin
+      raise "error"
+    rescue
+    end
+    eval("class Foo; end")
+    Insurance.set_trace_func nil
+
+    assert_equal(["line", 21],
+                 events.shift)     # a = 1
+    assert_equal(["line", 22],
+                 events.shift)     # foo
+    assert_equal(["call", 6],
+                 events.shift)     # foo
+    assert_equal(["return", 6],
+                 events.shift)     # foo
+    assert_equal(["line", 23],
+                 events.shift)     # a
+    assert_equal(["line", 24],
+                 events.shift)     # b = 1 + 2
+    assert_equal(["c-call", 24],
+                 events.shift)     # 1 + 2
+    assert_equal(["c-return", 24],
+                 events.shift)     # 1 + 2
+    assert_equal(["line", 25],
+                 events.shift)     # if b == 3
+    assert_equal(["line", 25],
+                 events.shift)     # if b == 3
+    assert_equal(["c-call", 25],
+                 events.shift)     # b == 3
+    assert_equal(["c-return", 25],
+                 events.shift)     # b == 3
+    assert_equal(["line", 26],
+                 events.shift)     # case b
+    assert_equal(["line", 27],
+                 events.shift)     # when 2
+    assert_equal(["c-call", 27],
+                 events.shift)     # when 2
+    assert_equal(["c-call", 27],
+                 events.shift)     # when 2
+    assert_equal(["c-return", 27],
+                 events.shift)     # when 2
+    assert_equal(["c-return", 27],
+                 events.shift)     # when 2
+    assert_equal(["line", 29],
+                 events.shift)     # when 3
+    assert_equal(["c-call", 29],
+                 events.shift)     # when 3
+    assert_equal(["c-return", 29],
+                 events.shift)     # when 3
+    assert_equal(["line", 30],
+                 events.shift)     # c = "b == 3"
+    assert_equal(["line", 33],
+                 events.shift)     # begin
+    assert_equal(["line", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-call", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-call", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-call", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-return", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-return", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-call", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-return", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-call", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-return", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["raise", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["c-return", 34],
+                 events.shift)     # raise "error"
+    assert_equal(["line", 37],
+                 events.shift)     # eval(<<EOF)
+    assert_equal(["c-call", 37],
+                 events.shift)     # eval(<<EOF)
+    assert_equal(["line", 1],
+                 events.shift)     # class Foo
+    assert_equal(["c-call", 1],
+                 events.shift)     # class Foo
+    assert_equal(["c-return", 1],
+                 events.shift)     # class Foo
+    assert_equal(["class", 1],
+                 events.shift)     # class Foo
+    assert_equal(["end", 1],
+                 events.shift)     # class Foo
+    assert_equal(["c-return", 37],
+                 events.shift)     # eval(<<EOF)
+    assert_equal(["line", 38],
+                 events.shift)     # set_trace_func nil
+    assert_equal(["c-call", 38],
+                 events.shift)     # set_trace_func nil
+   assert_equal([], events)
+
+    events = bar
+    Insurance.set_trace_func(nil)
+    assert_equal(["line", 13], events.shift)
+    assert_equal(["return", 9], events.shift)
+    assert_equal(["line", 133], events.shift)
+    assert_equal(["c-call", 133], events.shift)
+    assert_equal([], events)
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.6
+specification_version: 1
+name: insurance
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-10-28
+summary: Code coverage analysis package.
+require_paths: 
+  - lib
+email: scott@elitists.net
+homepage: http://lunchboxsoftware.com/insurance
+rubyforge_project: insurance
+description: Insurance is a code coverage analysis utility.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Scott Barron
+files: 
+  - extconf.rb
+  - insurance_tracer.c
+  - bin/railscov
+  - lib/insurance
+  - lib/insurance.rb
+  - lib/insurance/analyzer.rb
+  - lib/insurance/formatter.rb
+  - lib/insurance/generators
+  - lib/insurance/source_file.rb
+  - lib/insurance/templates
+  - lib/insurance/generators/rails
+  - lib/insurance/generators/rails/insurance
+  - lib/insurance/generators/rails/loader.rb
+  - lib/insurance/generators/rails/insurance/insurance_generator.rb
+  - lib/insurance/generators/rails/insurance/templates
+  - lib/insurance/generators/rails/insurance/templates/insurance.rake
+  - lib/insurance/templates/code-page.rhtml
+  - lib/insurance/templates/index.rhtml
+  - test/test_settracefunc.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - railscov
+extensions: 
+  - extconf.rb
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: syntax
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.0.0
+      version: