autometric 0.0.1

data/.autometric.example

@@ -0,0 +1,60 @@
+def growl(title, msg, pri=0, stick="", image="")
+  image_arg = (!image.empty?) ? "--image #{image}" : ""
+  system "growlnotify -n autometric #{image_arg} -p #{pri} -m \"#{msg}\" #{title} #{stick}" 
+end
+
+Autocoverage.add_hook :initialize do |at|
+  at.threshold = 90.0
+end
+
+Autocoverage.add_hook :failed do |at|
+  growl("Code Coverage Failed","#{at.coverage}% code coverage", 2, "", "~/.autometric_images/coverage_failed.png")
+end
+
+Autocoverage.add_hook :passed do |at|
+  growl("Code Coverage Passed", "#{at.coverage}% code coverage", -2, "", "~/.autometric_images/coverage_passed.png") #if at.tainted
+end
+
+Autocoverage.add_hook :increased do |at|
+  growl("Code Coverage Increased","#{"%.3f" % (at.coverage - at.previous_coverage)}% code coverage increase", 2, "", "~/.autometric_images/increase.png")
+end
+
+Autocoverage.add_hook :decreased do |at|
+  growl("Code Coverage Decreased", "#{"%.3f" % (at.previous_coverage - at.coverage)}% code coverage decrease", -2, "", "~/.autometric_images/decrease.png") #if at.tainted
+end
+
+Autocyclo.add_hook :erred do |at|
+  lines = at.errors.collect {|e| "#{e[:rating]} #{e[:id]}" }
+  message = lines.length > 5 ? lines[0...5].join("\n") + "\n..." : lines.join("\n")
+  growl("Cyclomatic Complexity Errors", message, 1, "", "~/.autometric_images/cyclo_error.png")
+end
+
+Autocyclo.add_hook :warned do |at|
+  lines = at.warnings.collect {|w| "#{w[:rating]} #{w[:id]}" }
+  message = lines.length > 5 ? lines[0...5].join("\n") + "\n..." : lines.join("\n")
+  growl("Cyclomatic Complexity Warnings", "#{message}", 2, "", "~/.autometric_images/cyclo_warn.png")
+end
+
+Autotoken.add_hook :erred do |at|
+  lines = at.errors.collect {|e| "#{e[:rating]} #{e[:id]}" }
+  message = lines.length > 5 ? lines[0...5].join("\n") + "\n..." : lines.join("\n")
+  growl("Token Complexity Errors", message, 1, "", "~/.autometric_images/cyclo_error.png")
+end
+
+Autotoken.add_hook :warned do |at|
+  lines = at.warnings.collect {|w| "#{w[:rating]} #{w[:id]}" }
+  message = lines.length > 5 ? lines[0...5].join("\n") + "\n..." : lines.join("\n")
+  growl("Token Complexity Warnings", "#{message}", 2, "", "~/.autometric_images/cyclo_warn.png")
+end
+
+Autoflog.add_hook :flogged do |at|
+  growl("Flog Score", "#{"%.3f" % at.score}", 2, "", "~/.autometric_images/flog.png")
+end
+
+Autoflog.add_hook :increased do |at|
+  growl("Flog Score Increased", "#{"%.3f" % (at.score - at.previous_score)}", -2, "", "~/.autosuite_images/flog_increase.png")
+end
+
+Autoflog.add_hook :decreased do |at|
+  growl("Flog Score Decreased", "#{"%.3f" % (at.previous_score - at.score)}", -2, "", "~/.autosuite_images/flog_decrease.png")
+end

data/History.txt

@@ -0,0 +1,6 @@
+== 0.0.1 / 2007-11-3
+
+* Initial version with support for:
+  * rcov
+  * saikuro (cyclomatic and token complexity)
+  * flog

data/Manifest.txt

@@ -0,0 +1,23 @@
+.autometric.example
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/autocoverage
+bin/autocyclo
+bin/autometric
+bin/autoflog
+bin/autotoken
+lib/auto.rb
+lib/autocoverage.rb
+lib/autocyclo.rb
+lib/autoflog.rb
+lib/autometric.rb
+lib/metaid.rb
+lib/util.rb
+lib/autometric/discover.rb
+lib/autometric/rails.rb
+lib/autometric/rspec.rb
+spec/autocoverage_rspec_spec.rb
+spec/autocoverage_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,75 @@
+autometric
+    by Ben Burkert
+    http://autometric.rubyforge.org/
+
+== DESCRIPTION:
+  
+autometric is comprised of 5 tools: autometric, autocyclo, autotoken, autoflog, and autocoverage.
+
+autocoverage runs rcov code coverage on your code whenever your library or test code changes.
+
+autoflog runs flog code analysis on your library code.
+
+autotoken runs saikuro's token complexity on your library code.
+
+autocyclo runs saikuro's cyclomatic complexity on your library code.
+
+autometric manages the multiple automatons that monitor your code.
+
+== FEATURES/PROBLEMS:
+  
+* Initial version with support for:
+  * rcov
+  * saikuro (cyclomatic and token complexity)
+  * flog
+
+== SYNOPSIS:
+
+  autometric -a
+
+== REQUIREMENTS:
+
+For autocoverage:
+* rcov
+
+For autotoken & autocyclo
+* saikuro
+
+For autoflog
+* flog
+* Hpricot
+
+== INSTALL:
+
+To install with Rubygems:
+* sudo gem install autometric
+* (optional) sudo gem install flog
+* (optional) sudo gem install rcov
+
+To install saikuro, follow the instructions at:
+* http://saikuro.rubyforge.org
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Ben Burkert
+
+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/Rakefile

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/lib")
+
+require 'rubygems'
+require 'hoe'
+require './lib/autometric.rb'
+require 'spec/rake/spectask'
+
+Hoe.new('autometric', Autometric::VERSION) do |p|
+  p.rubyforge_name = 'autometric'
+  p.author = 'Ben Burkert'
+  p.email = 'ben@benburkert.com'
+  p.summary = 'Continuously analyzes your code with rcov, saikuro, and flog'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/bin/autocoverage

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby -ws
+
+require 'autometric'
+
+Autometric.run(['-c'])

data/bin/autocyclo

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby -ws
+
+require 'autometric'
+
+Autometric.run(['-y'])

data/bin/autoflog

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby -ws
+
+require 'autometric'
+
+Autometric.run(['-f'])

data/bin/autometric

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby -ws
+
+require 'autometric'
+
+Autometric.run(ARGV)

data/bin/autotoken

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby -ws
+
+require 'autometric'
+
+Autometric.run(['-t'])

data/lib/auto.rb

@@ -0,0 +1,149 @@
+require 'find'
+require 'rbconfig'
+
+class CommandError < StandardError; end
+
+class Auto
+  
+  unless defined? WINDOZE then
+    WINDOZE = /win32/ =~ RUBY_PLATFORM
+    SEP = WINDOZE ? '&' : ';'
+  end
+  
+  class << self
+    
+    attr_accessor :hooks, :discoveries
+    
+    def hooks
+      @hooks ||= Hash.new { |h,k| h[k] = [] }
+    end
+    
+    def discoveries
+      @discoveries ||= []
+    end
+    
+    def add_hook name, &blk
+      hooks[name] << blk
+    end
+    
+    def add_discovery &proc
+      discoveries << proc
+    end
+    
+    def autodiscover
+      style = []
+
+      $:.push(*Dir["vendor/plugins/*/lib"])
+      paths = $:.dup
+
+      begin
+        require 'rubygems'
+        paths.push(*Gem.latest_load_paths)
+      rescue LoadError => e
+        # do nothing
+      end
+
+      paths.each do |d|
+        f = File.join(d, 'autometric', 'discover.rb')
+        load f if File.exist? f
+      end
+
+      discoveries.map { |proc| proc.call }.flatten.compact.sort.uniq
+    end
+    
+    def run *args
+      new(*args).run
+    end
+  end
+  
+  attr_accessor :output, :sleep, :wants_to_quit, :modified, :working_dirs, :file_masks
+  
+  def initialize(output = $stdout)
+    @output = output
+    @sleep = 2
+    @modified = nil
+    @interrupted = @wants_to_quit = false
+    @working_dirs = %w( lib )
+
+    @file_masks = {
+      :lib => /^lib\/.*\.rb$/
+    }
+  end
+  
+  def hook(name)
+    self.class.hooks[name].inject(false) do |handled,plugin|
+      plugin[self] || handled
+    end
+  end
+  
+  def reset
+    @modified = last_modified_time
+  end
+  
+  def wait_for_changes
+    loop do
+      mtime = last_modified_time
+      if @modified.nil? || mtime > @modified
+        @modified = mtime
+        break
+      end
+      Kernel::sleep(@sleep)
+    end
+  end
+  
+  def last_modified_time
+    find_files.collect {|f| File::mtime(f) }.max
+  end
+  
+  def find_files(masks = nil)
+    masks ||= @file_masks.collect{|k,v| v if @working_dirs.include? k.to_s}.compact
+    files = []
+    
+    Find.find '.' do |f|
+      filename = f.sub(/^\.\//, '')
+      files << f if [masks].flatten.any? { |mask| filename =~ mask }
+    end
+    
+    return files
+  end
+  
+  def run
+    hook :run
+
+    reset
+    loop do # ^c handler
+      run_metric
+      wait_for_changes
+    end
+  end
+  
+  def run_metric
+    @wants_to_quit ||= false
+    cmd = make_cmd
+
+    hook :run_command
+    @output.puts cmd
+    
+    @results = []
+    line = []
+
+    IO.popen(cmd) do |stdout|
+      @results = stdout.read
+    end
+    
+    @output << @results
+    hook :ran_command
+
+    handle_results(@results)
+  end
+  
+  alias_method :old_method_missing, :method_missing
+  
+  def method_missing(id, *args)
+    if match = id.to_s.match(/_files$/)
+      find_files(@file_masks[match.pre_match.to_sym])
+    else
+      old_method_missing(id, *args)
+    end
+  end
+end

data/lib/autocoverage.rb

@@ -0,0 +1,58 @@
+require 'find'
+
+class CommandError < StandardError; end
+
+class Autocoverage < Auto
+  requires_command :ruby, :rcov, :testrb
+  
+  attr_accessor :threshold, :coverage, :previous_coverage
+  
+  def initialize(*args)
+    super(*args)
+    
+    @threshold = 100.0
+    @opts = ["--no-html", "--text-report", "--exclude", "#{test_runner},test,examples"]
+    @previous_coverage = nil
+    @working_dirs = %w( lib test )
+
+    @file_masks = {
+      :lib => /^lib\/.*\.rb$/,
+      :test => /^test\/(.*\/)?test_.*rb$/
+    }
+    
+    hook :initialize
+  end
+  
+  def make_cmd
+    "#{ruby} -S \"#{rcov}\" #{@opts.join(' ')} #{test_runner} -- #{test_files.join(' ')}"
+  end
+  
+  alias_method :test_runner, :testrb
+  
+  def handle_results(results)
+    coverage_result = coverage_results(results).first
+    return if coverage_result.nil?
+    
+    @coverage = coverage_result.scan(/^\d{0,3}\.\d+/).first.to_f
+    
+    if @threshold > @coverage
+      hook :failed
+    else
+      hook :passed
+    end
+    
+    if @previous_coverage
+      if @previous_coverage < @coverage
+        hook :increased
+      elsif @previous_coverage > @coverage
+        hook :decreased
+      end
+    end
+    
+    @previous_coverage = @coverage
+  end
+  
+  def coverage_results(results)
+    results.scan(/^\d{0,3}\.\d+%\s+\d+ file\(s\)\s+\d+ Lines\s+\d+ LOC$/)
+  end
+end

data/lib/autocyclo.rb

@@ -0,0 +1,82 @@
+class Autocyclo < Auto
+  requires_command :ruby, :saikuro
+  
+  class << self
+    alias_method :old_meets_requirements?, :meets_requirements?
+    
+    def meets_requirements?
+      begin
+        require 'rubygems'
+        require 'Hpricot'
+        require 'fileutils'
+        old_meets_requirements?
+      rescue
+        nil
+      end
+    end
+  end
+  
+  attr_accessor :errors, :warnings, :output_dir, :index_file, :run_type
+  
+  def initialize(*args)
+    args, options = args_and_options(*args)
+    super(*args)
+    
+    @warning_level = options[:token_run] ? 20 : 10
+    @error_level = options[:token_run] ? 30 : 20
+    @run_type = options[:token_run] ? "-t" : "-c"
+    @opts = "-y 0"
+    @output_dir = options[:token_run] ? "token" : "cyclo"
+    @index_file = options[:token_run] ? "index_token.html" : "index_cyclo.html"
+    @errors, @warnings = [], []
+    @working_dirs = %w( lib )
+    
+    hook :initialize
+  end
+  
+  def errors_and_warnings(doc)
+    errors, warnings = [], []
+    
+    complexity_table = doc / :table
+    (complexity_table / :tr).each do |tr|
+      tds = tr / :td
+      
+      unless tds.empty? || tds[2][:class].nil?
+        sep = tds[0].inner_text =~ /::$/ ? "" : "#"
+        if tds[2][:class] == "error"
+          errors << { :id => "#{tds[0].inner_text}#{sep}#{tds[1].inner_text}", :rating => tds[2].inner_text.to_i }
+        elsif tds[2][:class] == "warning"
+          warnings << { :id => "#{tds[0].inner_text}#{sep}#{tds[1].inner_text}", :rating => tds[2].inner_text.to_i }
+        end
+      end
+    end
+    
+    return errors, warnings
+  end
+  
+  def handle_results(stdout)
+    doc = Hpricot(open("#{@output_dir}/#{@index_file}"))
+    
+    @errors, @warnings = errors_and_warnings(doc)
+    
+    @errors.sort_by   {|e| e[:rating] }
+    @warnings.sort_by {|w| w[:rating] }
+    
+    hook :erred unless @errors.empty?
+    hook :warned unless @warnings.empty?
+    
+    FileUtils.rm_rf "./#{@output_dir}"
+  end
+  
+  def make_cmd
+    "#{saikuro} #{@run_type} -i #{@working_dirs.join(' -i ')} -w #{@warning_level} -e #{@error_level} #{@opts} -f html -o ./#{@output_dir}"
+  end
+end
+
+class Autotoken < Autocyclo
+  def initialize(*args)
+    args, options = args_and_options(*args)
+    
+    super(*args.push(options.merge(:token_run => true)))
+  end
+end

data/lib/autoflog.rb

@@ -0,0 +1,38 @@
+class Autoflog < Auto
+  requires_command :flog
+  
+  attr_accessor :score, :previous_score
+  
+  def initialize(*args)
+    super(*args)
+    
+    @coverage = @previous_score = nil
+  end
+  
+  def make_cmd
+    "#{flog} #{@working_dirs.join(' ')}"
+  end
+  
+  def handle_results(results)
+    flog_result = flog_results(results).first
+    return if flog_result.nil?
+    
+    @score = flog_result.scan(/\d*\.?\d*$/).first.to_f
+    
+    hook :flogged
+    
+    if @previous_score
+      if @previous_score < @score
+        hook :increased
+      elsif @previous_score > @score
+        hook :decreased
+      end
+    end
+    
+    @previous_score = @score
+  end
+  
+  def flog_results(results)
+    results.scan(/Total score = \d*\.?\d*$/)
+  end
+end

data/lib/autometric.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'rbconfig'
+require 'find'
+
+require 'metaid'
+require 'util'
+require 'auto'
+require 'autocoverage'
+require 'autocyclo'
+require 'autoflog'
+
+class Autometric < Auto
+  VERSION = '0.0.1'
+  
+  RUNNERS = {
+    'c' => Autocoverage,
+    'y' => Autocyclo,
+    't' => Autotoken,
+    'f' => Autoflog
+    }
+  
+  attr_accessor :argv
+  
+  def initialize(argv = [])
+    @argv = argv
+    @wants_to_quit = @interrupted = nil
+  end
+  
+  def run()
+    targets = runners.collect { |klass| find_target klass }
+    targets = targets.find_all {|target| target.meets_requirements? }
+    
+    return if targets.empty?
+    
+    @thread_map = targets.to_h do |target|
+      Thread.start(target) do |target|
+        target.run
+        target.hook :thread_terminated
+      end
+    end
+    
+    hook :run
+    add_sigint_handler
+    
+    loop do # ^c handler
+      begin
+        Kernel::sleep
+      rescue Interrupt
+        if @wants_to_quit
+          break
+        else
+          reset
+        end
+      end
+    end
+    
+    hook :quit
+  end
+  
+  def add_sigint_handler
+    trap 'INT' do
+      if @interrupted then
+        @wants_to_quit = true
+      else
+        unless hook :interrupt then
+          puts "Interrupt a second time to quit"
+          @interrupted = true
+          Kernel::sleep(1.5)
+        end
+        raise Interrupt, nil # let the run loop catch it
+      end
+    end
+  end
+  
+  def runners
+    return RUNNERS.values if @argv.any? {|arg| arg =~ /a/ } || @argv.empty?
+    
+    klasses = @argv.collect do |arg|
+      RUNNERS.collect { |flag, klass| klass if arg =~ Regexp.compile(flag) }.compact
+    end
+    
+    klasses.flatten
+  end
+  
+  def find_target(klass)
+    style = klass.autodiscover
+    target = klass
+    unless style.empty? then
+      mod = "autometric/#{style.join("_")}"
+      puts "loading #{mod}"
+
+      begin
+        require mod
+      rescue LoadError
+        abort "#{klass.name} style #{mod} doesn't seem to exist.  Aborting."
+      end
+      target = klass.const_get(style.map{|s| s.capitalize}.join)
+    end
+    target
+  end
+  
+  def reset
+    @interrupted = @wants_to_quit = false
+    @thread_map.each do |target, thread|
+      thread.kill if thread.status
+      @thread_map[target] = Thread.start(target) do |target|
+        target.run
+        target.hook :thread_terminated
+      end
+    end
+  end
+end
+
+unless defined? $debug
+  if test ?f, '.autometric' then
+    load '.autometric'
+  elsif test ?f, File.expand_path('~/.autometric') then
+    load File.expand_path('~/.autometric')
+  end
+end

data/lib/autometric/discover.rb

@@ -0,0 +1,7 @@
+Autocoverage.add_discovery do
+  "rspec" if File.exist?('spec')
+end
+
+Autocyclo.add_discovery do
+  "rails" if File.exist?('config/environment.rb')
+end

data/lib/autometric/rails.rb

@@ -0,0 +1,19 @@
+class Autocyclo::Rails < Autocyclo
+  alias_hooks_to Autocyclo
+  
+  def initialize(*args)
+    super(*args)
+    
+    @working_dirs = %w( lib app )
+  end
+end
+
+class Autoflog::Rails < Autoflog
+  alias_hooks_to Autoflog
+  
+  def initialize(*args)
+    super(*args)
+    
+    @working_dirs = %( lib app )
+  end
+end

data/lib/autometric/rspec.rb

@@ -0,0 +1,13 @@
+class Autocoverage::Rspec < Autocoverage
+  requires_command :spec
+  alias_hooks_to Autocoverage
+  
+  def initialize(*args)
+    super(*args)
+    
+    @file_masks[:test] = /^spec\/.*_spec\.rb$/
+    @opts = ["--no-html", "--text-report", "--exclude", "examples,spec,#{test_runner}"]
+  end
+  
+  alias_method :test_runner, :spec
+end

data/lib/metaid.rb

@@ -0,0 +1,17 @@
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  
+  def meta_eval(*args, &blk); metaclass.instance_eval(*args, &blk); end
+  
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/util.rb

@@ -0,0 +1,89 @@
+class Object
+  def args_and_options(*args)
+    options = Hash === args.last ? args.pop : {}
+    return args, options
+  end
+end
+
+class Array
+  def to_h(&block)
+    Hash[*self.collect { |v|
+      [v, block.call(v)]
+    }.flatten]
+  end
+end
+
+module RubyCommands
+  module Methods
+    def ruby_command(command_name)
+      command_name = command_name.to_s
+      commands = [File.join('bin', command_name), File.join(Config::CONFIG['bindir'], command_name)]
+
+      commands.each do |command|
+        if File.exists?(command)
+          unless File::ALT_SEPARATOR.nil? then
+            command.gsub! File::SEPARATOR, File::ALT_SEPARATOR
+          end
+          return command
+        end
+      end
+
+      raise CommandError, "No #{command_name} command could be found!"
+    end
+  end
+  
+  def self.included(receiver)
+    receiver.extend         Methods
+    receiver.send :include, Methods
+  end
+end
+
+class Module
+  def requires_command(*args)
+    include RubyCommands
+    
+    args.each do |command|
+      class_def command do
+        ruby_command(command)
+      end
+      
+      meta_def command do
+        ruby_command(command)
+      end
+    end
+    
+    meta_def :meets_requirements? do
+      begin
+        args.each {|command| ruby_command(command.to_s) }
+        true
+      rescue
+        nil
+      end
+    end
+  end
+  
+  def alias_hooks_to(klass)
+    class_eval do
+      class << self
+        attr_accessor :super_klass
+        
+        def super_klass=(klass)
+          @super_klass = klass
+        end
+        
+        undef hooks
+        def hooks
+          @super_klass.hooks
+        end
+        
+        undef add_hook
+        def add_hook(name, &blk)
+          @super_klass.add_hook(name, &blk)
+        end
+        
+      end
+    end
+    
+    self.super_klass = klass
+  end
+end

data/spec/autocoverage_rspec_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Autocoverage::Rspec do
+  before(:each) do
+    @auto = Autocoverage::Rspec.new
+  end
+  
+  it "should have a spec mask for tests" do
+    @auto.file_masks[:test].should == /^spec\/.*_spec\.rb$/
+  end
+  
+  it "should return the spec command for test_runner" do
+    @auto.test_runner.should =~ /spec$/
+  end
+end

data/spec/autocoverage_spec.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/spec_helper'
+describe Autocoverage, "defaults" do
+  before(:each) do
+    @auto = Autocoverage.new
+  end
+  
+  it "should have a threshold of 100.0" do
+    @auto.threshold.should == 100.0
+  end
+  
+  it "should not have a coverage value" do
+    @auto.coverage.should be_nil
+  end
+  
+  it "should not have a previous coverage value" do
+    @auto.previous_coverage.should be_nil
+  end
+  
+  it "should look for rb files in the 'lib' dir" do
+    @auto.file_masks.values.should include(/^lib\/.*\.rb$/)
+  end
+  
+  it "should look for test files in the 'test' dir" do
+    @auto.file_masks.values.should include(/^test\/(.*\/)?test_.*rb$/)
+  end
+end
+
+describe Autocoverage, "coverage command" do
+  before(:each) do
+    @auto = Autocoverage.new
+    @alt_separator = File::ALT_SEPARATOR
+  end
+  
+  after(:each) do
+    File::ALT_SEPARATOR = @alt_separator unless File::ALT_SEPARATOR == @alt_separator
+  end
+  
+  it "should exclude the test runner" do
+    @auto.make_cmd.should =~ Regexp.compile("--exclude #{@auto.test_runner}")
+  end
+  
+  it "should exclude the test directory" do
+    @auto.make_cmd.should =~ Regexp.compile(/--exclude .*,test/)
+  end
+  
+  it "should work if File::ALT_SEPARATOR has a value" do
+    original = @auto.make_cmd
+    File::ALT_SEPARATOR = File::SEPARATOR
+    @auto.make_cmd.should == original
+  end
+  
+  it "should raise an exception if it cannot find rcov" do
+    File.should_receive(:exists?).at_least(:once).and_return { |arg| true unless arg =~ /rcov/ }
+    lambda { @auto.make_cmd }.should raise_error(CommandError)
+  end
+
+  it "should raise an exception if it cannot find testrb" do
+    File.should_receive(:exists?).at_least(:once).and_return { |arg| true unless arg =~ /testrb/ }
+    lambda { @auto.make_cmd }.should raise_error(CommandError)
+  end
+  
+  #it "should halt running if an interupt is detected" do
+  #  @auto.should_receive(:add_sigint_handler)
+  #  @auto.should_receive(:run_metric).and_return { raise Interrupt, "test interrupt" }
+  #  @auto.wants_to_quit = true
+  #  @auto.run
+  #end
+end
+
+describe Autocoverage, "results" do
+  before(:each) do
+    Autocoverage.hooks.clear
+    @auto = Autocoverage.new
+    @full_coverage, @half_coverage = <<-FULL, <<-HALF
+1 tests, 1 assertions, 0 failures, 0 errors
++----------------------------------------------------+-------+-------+--------+
+|                  File                              | Lines |  LOC  |  COV   |
++----------------------------------------------------+-------+-------+--------+
+|lib/full_coverage.rb                                |     5 |     5 | 100.0% |
++----------------------------------------------------+-------+-------+--------+
+|Total                                               |     5 |     5 | 100.0% |
++----------------------------------------------------+-------+-------+--------+
+100.0%   1 file(s)   5 Lines   5 LOC
+FULL
+1 tests, 1 assertions, 0 failures, 0 errors
++----------------------------------------------------+-------+-------+--------+
+|                  File                              | Lines |  LOC  |  COV   |
++----------------------------------------------------+-------+-------+--------+
+|lib/half_coverage.rb                                |    11 |    10 |  50.0% |
++----------------------------------------------------+-------+-------+--------+
+|Total                                               |    11 |    10 |  50.0% |
++----------------------------------------------------+-------+-------+--------+
+50.0%   1 file(s)   11 Lines   10 LOC
+HALF
+  end
+  
+  it "should update the coverage value" do
+    lambda{ @auto.handle_results(@full_coverage) }.should change{ @auto.coverage }.to(100.0)
+  end
+  
+  it "should update the previous_coverage" do
+    lambda{ @auto.handle_results(@full_coverage) }.should change{ @auto.previous_coverage }.to(100.0)
+  end
+  
+  it "should call failed if the coverage value is less than the threshold" do
+    Autocoverage.add_hook :failed do |at|
+      @fail_called = true
+    end
+    
+    lambda { @auto.handle_results(@half_coverage) }.should change{ @fail_called }
+  end
+  
+  it "should call passed if the coverage value is greater than the threshold" do
+    Autocoverage.add_hook :passed do |at|
+      @passed_called = true
+    end
+    
+    @auto.threshold = 50.0
+    lambda { @auto.handle_results(@full_coverage) }.should change{ @passed_called }
+  end
+  
+  it "should call passed if the coverage value is equal to the threshold" do
+    Autocoverage.add_hook :passed do |at|
+      @passed_called = true
+    end
+    
+    lambda { @auto.handle_results(@full_coverage) }.should change{ @passed_called }
+  end
+  
+  it "should call increased if the coverage value is greater than the previous coverage value" do
+    Autocoverage.add_hook :increased do |at|
+      @increased_called = true
+    end
+    
+    @auto.previous_coverage = 50.0
+    lambda { @auto.handle_results(@full_coverage) }.should change{ @increased_called }
+  end
+  
+  it "should call decreased if the coverage value is les than the previous coverage value" do
+    Autocoverage.add_hook :decreased do |at|
+      @decreased_called = true
+    end
+    @auto.previous_coverage = 100.0
+    lambda { @auto.handle_results(@half_coverage) }.should change{ @decreased_called }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+$debug = true
+
+require 'autometric'
+require 'autometric/rspec'
+require 'stringio'
+
+$examples_path = File.expand_path("#{File.dirname(__FILE__)}/../examples")

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: autometric
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-11-03 00:00:00 -05:00
+summary: Continuously analyzes your code with rcov, saikuro, and flog
+require_paths: 
+- lib
+email: ben@benburkert.com
+homepage: "    by Ben Burkert"
+rubyforge_project: autometric
+description: autocoverage runs rcov code coverage on your code whenever your library or test code changes.  autoflog runs flog code analysis on your library code.  autotoken runs saikuro's token complexity on your library code.  autocyclo runs saikuro's cyclomatic complexity on your library code.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ben Burkert
+files: 
+- .autometric.example
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/autocoverage
+- bin/autocyclo
+- bin/autometric
+- bin/autoflog
+- bin/autotoken
+- lib/auto.rb
+- lib/autocoverage.rb
+- lib/autocyclo.rb
+- lib/autoflog.rb
+- lib/autometric.rb
+- lib/metaid.rb
+- lib/util.rb
+- lib/autometric/discover.rb
+- lib/autometric/rails.rb
+- lib/autometric/rspec.rb
+- spec/autocoverage_rspec_spec.rb
+- spec/autocoverage_spec.rb
+- spec/spec_helper.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- autocoverage
+- autocyclo
+- autometric
+- autoflog
+- autotoken
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: