cucover 0.1.2

data/lib/cucover/cli_commands/version.rb

@@ -0,0 +1,13 @@
+module Cucover
+  module CliCommands
+    class Version
+      
+      def initialize(cli_args)
+      end
+      
+      def execute
+        puts File.read(File.dirname(__FILE__) + '/../../../VERSION')
+      end
+    end
+  end
+end

data/lib/cucover/controller.rb

@@ -0,0 +1,28 @@
+module Cucover
+  class Controller
+    def initialize(file_colon_line, store)
+      @file_colon_line = file_colon_line
+      @store = store
+    end
+    
+    def should_execute?
+      dirty? or failed_on_last_run?
+    end
+    
+    private
+    
+    def failed_on_last_run?
+      return false unless recording
+      recording.failed?
+    end
+    
+    def dirty?
+      Cucover.logger.debug("Assuming dirty as no recording found") and return true unless recording
+      recording.covered_files.any?{ |f| f.dirty? }
+    end
+    
+    def recording
+      @recording ||= @store.latest_recording(@file_colon_line)
+    end
+  end
+end

data/lib/cucover/cucumber_hooks.rb

@@ -0,0 +1,45 @@
+module Cucover
+  module FeatureElementExtensions
+    def reset_skipped_steps!
+      return unless @steps
+      @steps.each do |step|
+        step.instance_variable_set("@skip_invoke", nil)
+      end
+    end
+  end
+end
+
+module Cucover
+  module ExampleRowExtensions
+    include FeatureElementExtensions
+
+    def file_colon_line
+      "#{file}:#{line}"
+    end
+
+    def file
+      @scenario_outline.file_colon_line.split(':').first
+    end
+  end
+end
+
+Cucover::Monkey.extend_every Cucumber::Ast::Scenario => Cucover::FeatureElementExtensions
+Cucover::Monkey.extend_every Cucumber::Ast::OutlineTable::ExampleRow => Cucover::ExampleRowExtensions
+
+Before do |scenario_or_table_row|
+  scenario_or_table_row.reset_skipped_steps!
+
+  Cucover.logger.info("Starting #{scenario_or_table_row.class} #{scenario_or_table_row.file_colon_line}")
+  Cucover::Rails.patch_if_necessary
+
+  if Cucover.should_execute?(scenario_or_table_row)
+    Cucover.start_recording!(scenario_or_table_row)
+  else
+    announce "[ Cucover - Skipping clean scenario ]"
+    scenario_or_table_row.skip_invoke!
+  end
+end
+
+After do
+  Cucover.stop_recording!
+end

data/lib/cucover/line_numbers.rb

@@ -0,0 +1,10 @@
+require 'rbconfig'
+
+module Cucover
+  module LineNumbers
+    # Different Ruby versions have slightly different line numbers with rcov
+    def self.offset
+      Config::CONFIG['MINOR'] == '9' ? 0 : 1
+    end
+  end
+end

data/lib/cucover/logging_config.rb

@@ -0,0 +1,16 @@
+Logging.configure do
+  logger('Cucover') do
+    level     :debug
+    appenders 'logfile'
+  end
+
+  appender('logfile') do
+     type      'File'
+     level     :debug
+     filename  File.dirname(__FILE__) + '/../../tmp/cucover.log'
+     layout do
+       type        'Pattern'
+       pattern     '[%d] %l  %c : %m\n'
+     end
+   end  
+end

data/lib/cucover/monkey.rb

@@ -0,0 +1,14 @@
+module Cucover
+  module Monkey
+    def self.extend_every(args)
+      class_to_extend = args.keys.first
+      module_to_extend_with = args.values.first
+    
+      class_to_extend.instance_eval <<-PATCH
+        def new(*args)
+          super(*args).extend(#{module_to_extend_with})
+        end
+      PATCH
+    end
+  end
+end

data/lib/cucover/rails.rb

@@ -0,0 +1,23 @@
+module Cucover
+  module Rails
+    class << self
+      def patch_if_necessary
+        return if @patched
+        return unless defined?(ActionView)
+      
+        Monkey.extend_every ActionView::Base => Cucover::Rails::RecordsRenders
+        # Monkey.extend_every ActionView::Template => Cucover::Rails::RecordsRenders # TODO: patch nicer template
+        
+        @patched = true
+      end
+    end
+  
+    module RecordsRenders
+      def render(*args)
+        filename = args[0][:file].filename
+        Cucover.record_file(filename)
+        super
+      end
+    end
+  end
+end

data/lib/cucover/recorder.rb

@@ -0,0 +1,37 @@
+module Cucover
+  class Recorder
+    def initialize(scenario_or_table_row)
+      @scenario_or_table_row = scenario_or_table_row
+      @analyzer = Rcov::CodeCoverageAnalyzer.new
+      @additional_covered_files = []
+    end
+
+    def record_file!(source_file)
+      unless @additional_covered_files.include?(source_file)
+        @additional_covered_files << source_file
+      end
+    end
+
+    def start!
+      @start_time = Time.now
+      @analyzer.install_hook
+    end
+
+    def stop!
+      @end_time = Time.now
+      @analyzer.remove_hook
+      Cucover.logger.info("Finished recording #{@scenario_or_table_row.file_colon_line}.")
+      Cucover.logger.debug("Covered files: #{@analyzer.analyzed_files.join(',')}")
+      Cucover.logger.debug("Additional Covered files: #{@additional_covered_files.join(',')}")
+    end
+
+    def recording
+      Recording.new(
+        @scenario_or_table_row.file_colon_line,
+        @scenario_or_table_row.exception,
+        @additional_covered_files,
+        @analyzer,
+        @start_time, @end_time)
+    end
+  end
+end

data/lib/cucover/recording.rb

@@ -0,0 +1,66 @@
+module Cucover
+  class Recording < Struct.new(
+      :file_colon_line,
+      :exception,
+      :additional_covered_files,
+      :analyzer,
+      :start_time, :end_time)
+
+    IGNORE_PATTERNS = [
+      /gem/,
+      /vendor/,
+      /lib\/ruby/,
+      /cucover\/lib/
+    ]
+
+    def feature_filename
+      file_colon_line.split(':').first
+    end
+
+    def covers_file?(source_file)
+      covered_files.include?(source_file)
+    end
+
+    def covers_line?(source_file, line_number)
+      covered_files.detect{ |f| f.file == source_file }.covers_line?(line_number)
+    end
+
+    def covered_files
+      @covered_files ||= analyzed_covered_files + additional_covered_files
+    end
+
+    def failed?
+      !!exception
+    end
+
+    private
+
+    def additional_covered_files
+      super.map do |filename|
+        CoveredFile.new(filename, nil, self)
+      end
+    end
+
+    def analyzed_covered_files
+      filtered_analyzed_files.map do |filename|
+        lines, marked_info, count_info = analyzer.data(filename)
+        CoveredFile.new(filename, marked_info, self)
+      end
+    end
+
+    def boring?(file)
+      IGNORE_PATTERNS.any? do |expression|
+        file.match expression
+      end
+    end
+
+    def filtered_analyzed_files
+      analyzer.analyzed_files.reject{ |f| boring?(f) }
+    end
+
+    def normalized_files
+      cleaned_analyzed_files + additional_covered_files
+    end
+  end
+end
+require 'cucover/recording/covered_file'

data/lib/cucover/recording/covered_file.rb

@@ -0,0 +1,53 @@
+module Cucover
+  class Recording::CoveredFile
+    attr_reader :file
+
+    def initialize(full_filename, rcov_marked_info, recording)
+      @full_filename    = full_filename
+      @rcov_marked_info = rcov_marked_info
+      @recording        = recording
+      @file = File.expand_path(full_filename).gsub(/^#{Dir.pwd}\//, '')
+
+      extend HasLineNumberDetail if @rcov_marked_info
+    end
+
+    def dirty?
+      Cucover.logger.debug("#{file}     last modified at #{File.mtime(@full_filename)}")
+      Cucover.logger.debug("#{file} recording started at #{@recording.start_time}")
+      result = File.mtime(@full_filename).to_i >= @recording.start_time.to_i
+      Cucover.logger.debug("verdict: #{(result ? "dirty" : "not dirty")}")
+      result
+    end
+
+    def covers_line?(line_number)
+      covered_lines.include?(line_number)
+    end
+
+    def ==(other)
+      other == file
+    end
+
+    def to_s
+      "#{file}:#{covered_lines.join(':')}"
+    end
+
+    private
+
+    def covered_lines
+      ['<unknown lines>']
+    end
+
+    module HasLineNumberDetail
+      def covered_lines
+        return @covered_lines if @covered_lines
+
+        @covered_lines = []
+        @rcov_marked_info.each_with_index do |covered, index|
+          line_number = index + Cucover::LineNumbers.offset
+          @covered_lines << line_number if covered
+        end
+        @covered_lines
+      end
+    end
+  end
+end

data/lib/cucover/store.rb

@@ -0,0 +1,70 @@
+module Cucover
+  class Store
+    def initialize(cache = DiskCache.new)
+      @cache = cache
+    end
+
+    def latest_recordings
+      recordings.keys.map{ |file_colon_line| latest_recording(file_colon_line) }
+    end
+
+    def latest_recording(file_colon_line)
+      recordings[file_colon_line].sort{ |x, y| x.end_time <=> y.end_time }.last
+    end
+
+    def keep!(recording_data)
+      Cucover.logger.debug("Storing recording of #{recording_data.file_colon_line}")
+      recordings[recording_data.file_colon_line] << recording_data
+      @cache.save(@recordings)
+    end
+
+    def recordings_covering(source_file)
+      latest_recordings.select { |r| r.covers_file?(source_file) }
+    end
+
+    def recordings
+      ensure_recordings_loaded!
+      @recordings
+    end
+
+    private
+
+    def ensure_recordings_loaded!
+      return if @recordings
+
+      if @recordings = @cache.load
+        Cucover.logger.debug("Loaded #{@recordings.length} recording(s)")
+      else
+        Cucover.logger.debug("Starting with no existing coverage data.")
+        @recordings = Recordings.new
+      end
+    end
+
+    class Recordings < Hash
+      def [](key)
+        self[key] = [] if super.nil?
+        super
+      end
+    end
+
+    class DiskCache
+      def save(recordings)
+        Cucover.logger.debug("Saving #{recordings.length} recording(s) to #{data_file}")
+        File.open(data_file, 'w') { |f| f.puts Marshal.dump(recordings) }
+      end
+
+      def load
+        return unless File.exists?(data_file)
+
+        Cucover.logger.debug("Reading existing coverage data from #{data_file}")
+        File.open(data_file) { |f| Marshal.load(f) }
+      end
+
+      private
+
+      def data_file
+        Dir.pwd + '/cucover.data'
+      end
+    end
+  end
+end

data/lib/dependencies.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+gem     'logging',       '>= 1.4.1'
+require 'logging'
+
+gem     'cucumber',      '>= 0.3.1'
+require 'cucumber'
+
+gem     'rcov',          '>= 0.9.8'
+require 'rcov'

data/spec/cucover/cli_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Cucover::Cli do
+  describe "given a --coverage-of command" do
+    before(:each) do
+      @args = ['--coverage-of', 'lib/foo.rb']
+    end
+    
+    it "should create a CoverageOf command object and execute it" do
+      Cucover::CliCommands::CoverageOf.should_receive(:new).with(['--coverage-of', 'lib/foo.rb']).and_return(command = mock('command'))
+      command.should_receive(:execute)
+      cli = Cucover::Cli.new(@args)
+      cli.start
+    end
+  end
+  
+  describe "given arguments for Cucumber" do
+    before(:each) do
+      @args = ['--', 'c', 'd']
+    end
+    it "should pass the arguments after the -- to cucumber" do
+      cli = Cucover::Cli.new(@args)
+    
+      Kernel.stub!(:load).with(Cucumber::BINARY) do
+        ARGV.should == ['c', 'd']
+      end
+    
+      cli.start
+    end
+  end
+end

data/spec/cucover/controller_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Cucover
+  describe Controller do
+    describe "#should_execute?" do
+      before(:each) do
+        @store = mock(Store)
+        @example_id = 'foo.feature:123'
+      end
+      it "when no previous recording exists, it should always return true" do
+        @store.should_receive(:latest_recording).with(@example_id).and_return(nil)
+        Controller.new(@example_id, @store).should_execute?.should be_true
+      end
+    end
+  end
+end