jcov 1.0.1 → 1.1

data/jcov.gemspec

@@ -7,14 +7,13 @@ Gem::Specification.new do |s|
   s.version     = JCov::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Doug McInnes"]
-  s.email       = ["dmcinnes@yp.com"]
+  s.email       = ["doug@dougmcinnes.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.11.1"
-  s.add_dependency "rkelly",       "~> 1.0.4"
 
   s.add_development_dependency "cucumber",  "~> 1.0"
   s.add_development_dependency "aruba",     "~> 0.4.6"

data/lib/jcov.rb

@@ -1,9 +1,13 @@
 require 'v8'
-require 'rkelly'
 
 require 'jcov/version'
+require 'jcov/errors'
 require 'jcov/configuration'
 require 'jcov/commands'
+require 'jcov/loader'
+require 'jcov/context'
+require 'jcov/context/run_context'
+require 'jcov/context/instrumentation_context'
 require 'jcov/runner'
 require 'jcov/coverage'
 require 'jcov/reporter'

data/lib/jcov/commands.rb

@@ -4,8 +4,8 @@ module JCov::Commands
 
   # the check command
   class Check
-    def initialize args, options
-      config = JCov::Configuration.new options.config
+    def initialize(args, options)
+      config = JCov::Configuration.new(options)
 
       if config.filename
         puts "Using configuration file: #{config.filename}"
@@ -19,26 +19,26 @@ module JCov::Commands
 
   # the run command
   class Run
-    def initialize args, options
+    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)
+      config = JCov::Configuration.new(options)
 
-      runner = JCov::Coverage::CoverageRunner.new(config, options)
+      runner = JCov::Runner.new(config)
 
       runner.run
 
       abort "Test Failures! :(" if runner.failure_count > 0
 
       if options.report
-        JCov::Reporter::HTMLReporter.new(runner).report
+        JCov::Reporter::HTMLReporter.new(runner.coverage).report
       end
 
-      reporter = JCov::Reporter::ConsoleReporter.new(runner)
+      reporter = JCov::Reporter::ConsoleReporter.new(runner.coverage)
 
       abort unless reporter.report
     end

data/lib/jcov/configuration.rb

@@ -14,11 +14,17 @@ module JCov
       "test_runner"             => "test/javascripts/runner.js",
       "error_field"             => "error_count",
       "report_output_directory" => "jcov",
+      "verbose"                 => false,
+      "color"                   => true,
+      "coverage"                => true,
+      "report"                  => false,
+      "dump"                    => false
     }
 
-    def initialize file
-      @filename = find_file(file)
-      @config = DEFAULTS.merge(@filename && YAML.load_file(@filename) || {})
+    def initialize(options)
+      @filename = find_file(options.config)
+      @config = DEFAULTS.merge(options.__hash__)
+      @config.merge!(YAML.load_file(@filename)) if @filename
       create_readers
     end
 

data/lib/jcov/context.rb

@@ -0,0 +1,17 @@
+module JCov::Context
+
+  # create a V8 context object with our context methods mapped onto it
+  def create
+    @context = V8::Context.new
+
+    # map our context objects methods onto the v8 object
+    # doing this instead of using :with because of this:
+    # https://github.com/cowboyd/therubyracer/issues/251
+    (self.methods - Object.new.methods - [:create]).each do |method|
+      @context[method] = self.method(method)
+    end
+
+    @context
+  end
+
+end

data/lib/jcov/context/instrumentation_context.rb

@@ -0,0 +1,31 @@
+module JCov::Context
+    
+  class InstrumentationContext
+    include JCov::Context
+
+    def initialize(coverage_data)
+      @coverage_data = coverage_data
+    end
+
+    # called when a line can be covered by tests
+    def lineCovered(file, line, column)
+      # only record if the line hasn't been recorded yet
+      # or if it has, the line is not flagged with nil
+      if !@coverage_data[file].has_key?(line) || !@coverage_data[file].nil?
+        @coverage_data[file][line] = column
+      end
+    end
+
+    # called when a line should be ignored in the coverage report
+    def ignoreLine(file, line)
+      @coverage_data[file][line] = nil # set to nil so it's ignored
+    end
+
+    # for testing
+    def print(str)
+      puts str
+    end
+
+  end
+
+end

data/lib/jcov/context/run_context.rb

@@ -0,0 +1,44 @@
+module JCov::Context
+    
+  class RunContext
+    include JCov::Context
+
+    def initialize(loader)
+      @loader = loader
+      @coverage_data = loader.coverage_data
+    end
+
+    def print(s)
+      Kernel.print s
+    end
+
+    def println(*s)
+      Kernel.puts s
+    end
+
+    # so we can do our dotted line output
+    def putc(char)
+      $stdout.putc(char);
+      $stdout.flush();
+    end
+
+    # for JSpec
+    def readFile(file)
+      File.read(file)
+    end
+
+    def load(file)
+      # use the configured loader
+      content = @loader.load file
+
+      # evaluate the javascript
+      @context.eval(content, file)
+    end
+
+    # increment
+    def _coverage_tick(file, line)
+      @coverage_data[file][line] += 1
+    end
+  end
+
+end

data/lib/jcov/coverage.rb

@@ -1,151 +1,76 @@
 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)
+  class Coverage
 
-        override_runners_load_method
-        add_coverage_method_to_context
+    attr_accessor :loader
+    attr_accessor :config
 
-        @visitor = CoverageVisitor.new(coverage_data)
-        @parser  = RKelly::Parser.new
+    def initialize(config)
+      @config = config
 
-        @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
+      # for loading and instrumenting fiels
+      @loader = JCov::Loader.new(coverable_files, :dump => config.dump)
+    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
+    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
 
-      # 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
+    # reduce the coverage data to file, total line count, and covered line count
+    def reduced_coverage_data
+      # cache the result
+      @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
+            lines = examine_uncovered_file file
+
+            # this file was never run so it has zero coverage
+            cover = 0
+          else
+            # munge the count data together to get coverage
+            cover = lines.values.compact.inject(0) { |memo, count| memo + ((count > 0) ? 1 : 0) }
           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
+          # ignore nil values
+          total = lines.values.compact.count
 
-      # 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
+          [file, total, cover]
         end
-        @reduced_coverage_data
-      end
+    end
 
-      def get_binding
-        binding
-      end
+    def coverage_data
+      @loader.coverage_data
+    end
 
-    private
+    # for coverage reporting
+    def get_binding
+      binding
+    end
 
-      def add_coverage_method_to_context
-        runner.context['_coverage_tick'] = self.method('_coverage_tick')
-      end
+  private
 
-      def override_runners_load_method
-        runner.context['load'] = self.method('load')
-      end
+    # when a file is in the list to be examined but never loaded
+    # we have to load it ourselves to calculate the full coverage counts
+    def examine_uncovered_file(filename)
+      # run it through the Loader
+      # it will fill out the coverage data for this file
+      @loader.load filename
 
+      # re-get the lines
+      coverage_data[filename]
     end
 
   end
+
 end

data/lib/jcov/errors.rb

@@ -0,0 +1,6 @@
+module JCov
+
+  class ParseError < StandardError
+  end
+
+end

data/lib/jcov/js/parser.js

@@ -0,0 +1,44 @@
+// for acorn
+var self = this;
+
+JCov = (function () {
+
+  var calculateCoverageData = function (code, file) {
+    var tree = acorn.parse(code, {locations: true});
+
+    acorn.walk.simple(tree, {
+      Statement: function (node) {
+        // cover all statements
+        if (node.type !== "BlockStatement" &&
+            node.type !== "EmptyStatement") {
+          var pos = node.loc.start;
+          lineCovered(file, pos.line, pos.column);
+        }
+      },
+      IfStatement: function (node) {
+        // ignore else statements
+        if (node.alternate) {
+          ignoreLine(file, node.alternate.loc.start.line);
+        }
+
+        if (node.consequent.type !== "BlockStatement") {
+          var ifStart   = node.loc.start.line;
+          var thenStart = node.consequent.loc.start.line;
+          if (ifStart < thenStart) {
+            // ignore non-block single if statements if they're on
+            // their own line
+            ignoreLine(file, node.consequent.loc.start.line);
+          } else if (ifStart === thenStart) {
+            // single line if statement, mark the whole line
+            lineCovered(file, ifStart, 0);
+          }
+        }
+      }
+    });
+  };
+
+  return {
+    calculateCoverageData: calculateCoverageData
+  };
+
+})();