jcov 1.0.0

data/features/step_definitions/report_steps.rb

@@ -0,0 +1,54 @@
+RSpec::Matchers.define :have_line do |this_line|
+  match do |lines|
+    regex = Regexp.new(Regexp.escape(this_line))
+    lines.any? {|line| line =~ regex}.should be_true
+  end
+  failure_message_for_should do |list|
+    # generate and return the appropriate string.
+    "did not find \"#{this_line}\""
+  end
+  failure_message_for_should_not do |list|
+    "found \"#{this_line}\""
+  end
+end
+
+Given /^I open the report$/ do
+  visit "/report.html"
+end
+
+Then /^I should see "([^"]*)"$/ do |text|
+  page.should have_content text
+end
+
+Then /^I should see "([^"]*)" in the HTML$/ do |text|
+  page.html.should match Regexp.new(Regexp.escape(text))
+end
+
+Then /^I should see these lines (covered|not covered|uncoverable):$/ do |type, table|
+
+  # find all the lines of the given type
+  lines = case type
+          when 'covered'
+            all('.line[data-coverage!="0"][data-coverage!="uncoverable"] .code')
+          when 'not covered'
+            all('.line[data-coverage="0"] .code')
+          when 'uncoverable'
+            all('.line[data-coverage="uncoverable"] .code')
+          end
+
+  lines.map! &:text
+
+  # interate over the list and see if they match
+  table.hashes.each do |row|
+    lines.should have_line(row[:line])
+  end
+end
+
+When /^I click "([^\"]*)"$/ do |link|
+  click_link(link)
+end
+
+Then /^(?:|I )should be on (.+)$/ do |path|
+  current_path = URI.parse(current_url).path
+  File.expand_path(current_path).should == File.expand_path(path)
+end

data/features/support/env.rb

@@ -0,0 +1,29 @@
+lib_dir = File.expand_path('../../../lib', __FILE__)
+
+$:.unshift lib_dir
+
+require 'aruba/cucumber'
+require 'jcov'
+require 'rack'
+require 'capybara'
+require 'capybara/dsl'
+require 'capybara/cucumber'
+require 'capybara/session'
+
+Capybara.default_selector = :css
+
+include Capybara::DSL
+
+Capybara.app = Rack::Builder.new do
+  map "/" do
+    use Rack::Static, :urls => ["/"], :root => 'tmp/aruba/jcov'
+    run lambda {|env| [404, {}, '']}
+  end
+end.to_app
+
+Before do
+  @aruba_timeout_seconds = 10
+end
+
+# add the lib dir to RUBYLIB so bin/jcov can find what it needs
+ENV['RUBYLIB'] = lib_dir

data/jcov.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jcov/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jcov"
+  s.version     = JCov::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Doug McInnes"]
+  s.email       = ["dmcinnes@attinteractive.com"]
+  s.homepage    = ""
+  s.summary     = %q{Javascript Coverage Tool}
+  s.description = %q{Javascript Coverage Tool}
+
+  s.add_dependency "commander",    "~> 4.0"
+  s.add_dependency "therubyracer", "= 0.9.0"
+  s.add_dependency "rkelly",       "~> 1.0.4"
+
+  s.add_development_dependency "cucumber",  "~> 1.0"
+  s.add_development_dependency "aruba",     "~> 0.4.6"
+  s.add_development_dependency "capybara",  "~> 1.1.1"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.executables = ['jcov']
+end

data/lib/jcov.rb

@@ -0,0 +1,11 @@
+require 'v8'
+require 'rkelly'
+
+require 'jcov/version'
+require 'jcov/configuration'
+require 'jcov/commands'
+require 'jcov/runner'
+require 'jcov/coverage'
+require 'jcov/reporter'
+require 'jcov/reporter/console_reporter'
+require 'jcov/reporter/html_reporter'

data/lib/jcov/commands.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+
+module JCov::Commands
+
+  # the check command
+  class Check
+    def initialize args, options
+      config = JCov::Configuration.new options.config
+
+      if config.filename
+        puts "Using configuration file: #{config.filename}"
+      else
+        puts "No configuration file! Using defaults."
+      end
+
+      puts config
+    end
+  end
+
+  # the run command
+  class Run
+    def initialize args, options
+      # default to no color unless we're on a tty
+      options.default :color    => $stdout.tty?
+      options.default :coverage => true
+
+      options.args = args
+
+      config = JCov::Configuration.new(options.config)
+
+      runner = JCov::Coverage::CoverageRunner.new(config, options)
+
+      runner.run
+
+      abort "Test Failures! :(" if runner.failure_count > 0
+
+      if options.report
+        JCov::Reporter::HTMLReporter.new(runner).report
+      end
+
+      reporter = JCov::Reporter::ConsoleReporter.new(runner)
+
+      abort unless reporter.report
+    end
+  end
+
+end

data/lib/jcov/configuration.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+
+module JCov
+  class Configuration
+
+    LOCATIONS = %w{config/jcov.yml ./jcov.yml}
+
+    attr_reader :config
+    attr_reader :filename
+
+    DEFAULTS = {
+      "test_directory"          => "test/javascripts",
+      "source_directory"        => "public/javascripts",
+      "test_runner"             => "test/javascripts/runner.js",
+      "error_field"             => "error_count",
+      "report_output_directory" => "jcov",
+    }
+
+    def initialize file
+      @filename = find_file(file)
+      @config = DEFAULTS.merge(@filename && YAML.load_file(@filename) || {})
+      create_readers
+    end
+
+    def to_s
+      @config.to_yaml
+    end
+
+    # ignore unset configuration values
+    def method_missing method
+      nil
+    end
+
+    private
+
+    def find_file file
+      raise "Cannot find file \"#{file}\"" if file && !File.exists?(file)
+
+      file || LOCATIONS.find do |file|
+                File.exists?(file)
+              end
+    end
+
+    # create methods to access the configuration
+    def create_readers
+      @config.each_key do |key|
+        self.class.send(:define_method, key) do
+          @config[key]
+        end
+      end
+    end
+    
+  end
+end

data/lib/jcov/coverage.rb

@@ -0,0 +1,151 @@
+module JCov
+  module Coverage
+
+    # extend RKelly's ECMAVisitor to include our coverage_tick
+    class CoverageVisitor < RKelly::Visitors::ECMAVisitor
+      def initialize(coverage)
+        @coverage = coverage
+        @indent = 0
+      end
+
+      # whenever we hit a line, add the instrumentation
+      def visit_SourceElementsNode(o)
+        o.value.map { |x|
+          if (x.filename && x.line)
+            coverage = "_coverage_tick('#{x.filename}', #{x.line});"
+            @coverage[x.filename][x.line] = 0
+          end
+          "#{coverage || ""}#{indent}#{x.accept(self)}"
+        }.join("\n")
+      end
+    end
+
+
+    class CoverageRunner
+      attr_reader :config
+      attr_reader :options
+      attr_reader :runner
+      attr_reader :instrumented_files
+
+      def initialize config, options
+        @config  = config
+        @options = options
+
+        @runner = JCov::Runner.new(config, options)
+
+        override_runners_load_method
+        add_coverage_method_to_context
+
+        @visitor = CoverageVisitor.new(coverage_data)
+        @parser  = RKelly::Parser.new
+
+        @instrumented_files = {}
+      end
+
+      def coverable_files
+        if @coverable_files.nil?
+          # all the files we're testing on
+          @coverable_files = Dir.glob(File.join(config.source_directory, "**", "*.js"))
+          # only run coverage on files that we haven't specifically ignored
+          ignore = config.ignore || []
+          @coverable_files.delete_if {|file| ignore.any? {|i| file.match(i) }}
+          # remove the runner if it's in there
+          @coverable_files.delete(config.test_runner)
+        end
+        @coverable_files
+      end
+
+      def coverage_data
+        if @coverage_data.nil?
+          # set up coverage data structure
+          @coverage_data = {}
+          coverable_files.each {|file| @coverage_data[file] = {} }
+        end
+        @coverage_data
+      end
+
+      # our new load method
+      def load file
+        if instrumented_files[file]
+          # reuse previously loaded file
+          content = instrumented_files[file]
+        else
+          content = File.read(file)
+
+          # is this a file we need to instrument?
+          if coverable_files.include? file
+            # run it through the js parser and custom renderer
+            tree    = @parser.parse(content, file)
+            content = @visitor.accept(tree)
+
+            # cache the file if it's reloaded
+            instrumented_files[file] = content
+          end
+        end
+
+        runner.context.eval(content, file)
+      end
+
+      def _coverage_tick file, line
+        coverage_data[file][line] += 1
+      end
+
+      def run
+        runner.run
+      end
+
+      # proxy to runner
+      def failure_count
+        runner.failure_count
+      end
+
+      # reduce the coverage data to file, total line count, and covered line count
+      def reduced_coverage_data
+        if @reduced_coverage_data.nil?
+          @reduced_coverage_data = coverage_data.map do |file, lines|
+            # if we don't have any data for this file it was never loaded
+            if lines.empty?
+              # load it now
+              content = File.read(file)
+
+              # run it through the js parser and custom renderer
+              # the visitor will fill out the coverage data for this line
+              tree    = @parser.parse(content, file)
+              content = @visitor.accept(tree)
+
+              # re-get the lines
+              lines = coverage_data[file]
+
+              # this file was never run
+              cover = 0
+            else
+              # munge the count data together to get coverage
+              cover = lines.values.inject(0) { |memo, count| memo + ((count > 0) ? 1 : 0) }
+            end
+
+            total = lines.count
+
+            [file, total, cover]
+          end
+        end
+        @reduced_coverage_data
+      end
+
+      def get_binding
+        binding
+      end
+
+    private
+
+      def add_coverage_method_to_context
+        runner.context['_coverage_tick'] = self.method('_coverage_tick')
+      end
+
+      def override_runners_load_method
+        runner.context['load'] = self.method('load')
+      end
+
+    end
+
+  end
+end

data/lib/jcov/reporter.rb

@@ -0,0 +1,2 @@
+module JCov::Reporter
+end

data/lib/jcov/reporter/console_reporter.rb

@@ -0,0 +1,107 @@
+module JCov::Reporter
+
+  class ConsoleReporter
+
+    attr_accessor :total_count, :covered_count, :percent
+
+    def initialize coverage_runner
+      @coverage_runner = coverage_runner
+
+      calculate_total_coverage if report_coverage?
+    end
+
+    def report
+      if total_count && total_count == 0
+        # report a warning message if we're not checking any files for coverage
+        puts "No files were checked for coverage. Maybe your ignore list in #{config.filename} is too inclusive?"
+      elsif report_coverage?
+        report_file_coverage    if options.report
+        report_total_coverage
+        report_threshold_errors if config.threshold
+        passed?
+      else
+        true
+      end
+    end
+
+    private
+
+    def config
+      @coverage_runner.config
+    end
+
+    def options
+      @coverage_runner.options
+    end
+
+    # no_coverage.nil? because no_coverage gets set to false when set because it's prefixed as 'no'
+    def report_coverage?
+      options.report || options.no_coverage.nil? && options.coverage && options.test.nil? && options.args.empty?
+    end
+
+    # passes if any are true:
+    # 1. we're not checking a threshold
+    # 2. thresholds must match and they do
+    # 3. coverage percent is greater than or equal to threshold
+    def passed?
+      config.threshold.nil? ||
+      (config.threshold_must_match && percent == config.threshold) ||
+      percent >= config.threshold
+    end
+
+    # report an under threshold error
+    # report an over threshold error if threshold_must_match is set to true
+    def report_threshold_errors
+      if percent < config.threshold
+        puts "FAIL! Coverage is lower than threshold! #{percent}% < #{config.threshold}% :("
+      elsif config.threshold_must_match && percent != config.threshold
+        puts "Coverage does not match threshold! #{percent}% != #{config.threshold}%"
+        puts "Please raise the threshold in #{config.filename}"
+      end
+    end
+
+    def report_total_coverage
+      printf "\nTotal Coverage: (%d/%d) %3.1f%\n\n", covered_count, total_count, percent
+    end
+
+    def report_file_coverage
+      puts "\n"
+
+      puts "Coverage Report"
+      puts "===================="
+
+      filename_length = @coverage_runner.coverage_data.map(&:first).map(&:length).max
+
+      @coverage_runner.reduced_coverage_data.each do |file, total, cover|
+        if (total > 0)
+          percent = 100 * cover / total
+          coverage_string = "(#{cover}/#{total})"
+        else
+          percent = 100
+          coverage_string = "(EMPTY)"
+        end
+        if options.test.nil? || percent > 0 # only show ran files if we're doing a focused test
+          printf "%-#{filename_length}s %-10s %3s%\n", file, coverage_string, percent
+        end
+      end
+      puts "===================="
+    end
+
+    def calculate_total_coverage
+      @total_count   = 0
+      @covered_count = 0
+
+      @coverage_runner.reduced_coverage_data.each do |file, tot, cover|
+        if !config.test || cover > 0 # only show ran files if we're doing a focused test
+          @total_count   += tot
+          @covered_count += cover
+        end
+      end
+
+      # only keep one significant digit
+      @percent = (100.0 * @covered_count / @total_count).round(1)
+    end
+
+  end
+
+end