guard-jasmine 1.19.2 → 2.0.0beta1

data/lib/guard/jasmine/phantomjs/src/guard-jasmine.coffee

@@ -0,0 +1,101 @@
+
+# Set default values
+options =
+  url: phantom.args[0] || 'http://127.0.0.1:3000/jasmine'
+  timeout: parseInt(phantom.args[1] || 10000)
+
+# Create the web page.
+page = require('webpage').create()
+
+# Catch JavaScript errors
+# abort the request and return the error
+page.onError = (message, trace) ->
+    reportError "Javascript error encountered on Jasmine test page: #{ message }", trace
+
+# Once the page is initialized, setup the script for
+# the GuardReporter class
+page.onInitialized = ->
+    page.injectJs 'guard-reporter.js'
+    page.evaluate ->
+        window.onload = ->
+            window.reporter = new GuardReporter()
+            window.jasmine.getEnv().addReporter(window.reporter) if window.jasmine
+
+# Once the page is finished loading
+page.onLoadFinished = (status)->
+    if status isnt 'success'
+        reportError "Unable to access Jasmine specs at #{ options.url }, page returned status: #{status}"
+    else
+        waitFor reporterReady, jasmineAvailable, options.timeout, reporterMissing
+
+# Open web page, which will kick off the Jasmine test runner
+page.open options.url
+
+# Test if Jasmine and guard has been loaded
+reporterReady = ->
+    page.evaluate ->
+        window.jasmine && window.reporter
+
+# Start specs after they are have been loaded
+jasmineAvailable = ->
+    waitFor specsDone, exitSuccessfully, options.timeout, specsTimedout
+
+# Error message for when jasmine never loaded asynchronously
+reporterMissing = ->
+  text = page.evaluate -> document.getElementsByTagName('body')[0]?.innerText
+  reportError """
+            The reporter is not available!
+            Perhaps the url ( #{ options.url } ) is incorrect?
+
+            #{ text }
+            """
+
+# tests if the resultComplete flag is set on the reporter
+specsDone = ->
+    result = page.evaluate ->
+        window.reporter.resultComplete
+
+# We should end up here.  Logs the results as JSON and exits
+exitSuccessfully = ->
+    results  = page.evaluate -> window.reporter.results()
+    console.log JSON.stringify( results )
+    phantom.exit()
+
+
+# Error message for when specs time out
+specsTimedout = ->
+  text = page.evaluate -> document.getElementsByTagName('body')[0]?.innerText
+  reportError """
+            Timeout waiting for the Jasmine test results!
+
+            #{ text }
+            """
+
+# Wait until the test condition is true or a timeout occurs.
+#
+# @param [Function] test the test that returns true if condition is met
+# @param [Function] ready the action when the condition is fulfilled
+# @param [Number] timeout the max amount of time to wait in milliseconds
+#
+waitFor = (test, ready, timeout = 10000, timeoutFunction)->
+    condition = false
+    interval = undefined
+    start = Date.now(0)
+    wait = ->
+        if !condition && (Date.now() - start < timeout)
+            condition = test()
+        else
+          clearInterval interval
+          if condition
+              ready()
+          else
+              timeoutFunction()
+    interval = setInterval( wait, 250 )
+
+# Logs the error to the console as JSON and exits with status '1'
+reportError = (msg, trace=[])->
+    if 0 == trace.length
+        err = new Error();
+        trace = err.stack
+    console.log JSON.stringify({ error: msg, trace: trace })
+    phantom.exit(1)

data/lib/guard/jasmine/phantomjs/src/guard-reporter.coffee

@@ -0,0 +1,109 @@
+# Capture statements that were logged to the console
+# during spec execution.
+#
+# To do so it substitues it's own functions for the console.<levels>
+#
+extendObject = (a, b)->
+    for key,value of b
+        a[key] = value if b.hasOwnProperty(key)
+    return a
+
+
+class ConsoleCapture
+    # Instead of attempting to de-activate the console dot reporter in hacky ways,
+    # just ignore it's output
+    @DOT_REPORTER_MATCH = /\[\d+m[F.]..0m/
+    @levels: ['log','info','warn','error','debug' ]
+    @original = console
+
+    @original_levels = {}
+    @original_levels[level] = console[level] for level in ConsoleCapture.levels
+
+    constructor:->
+        @original = {}
+        @captured = []
+        this._reassign_level( level ) for level in ConsoleCapture.levels
+
+    revert: ->
+        for level in ConsoleCapture.levels
+            ConsoleCapture.original[level] = ConsoleCapture.original_levels[level]
+
+    _reassign_level: ( level )->
+        my = this
+        console[level] = ->
+            args = Array.prototype.slice.call(arguments, 0)
+            return if args[0] && args[0].toString && args[0].toString().match( ConsoleCapture.DOT_REPORTER_MATCH )
+            my.captured.push( [ level ].concat( args ) )
+            ConsoleCapture.original_levels[ level ].apply( ConsoleCapture.original, arguments )
+
+
+# Implements a Jasmine reporter
+class GuardReporter
+    @STACK_MATCHER=new RegExp("__spec__\/(.*):([0-9]+)","g")
+
+    jasmineStarted: ->
+        @console = new ConsoleCapture();
+        @startedAt = Date.now()
+        @currentSuite = { suites: [] }
+        @stack     = [ @currentSuite ]
+
+    suiteStarted: (suite)->
+        suite = extendObject({ specs: [], suites: [] }, suite )
+        @currentSuite.suites.push( suite )
+        @currentSuite = suite
+        @stack.push(suite)
+
+    suiteDone: (Suite)->
+        @stack.pop()
+        @currentSuite = @stack[@stack.length-1]
+
+    jasmineDone: ->
+        @resultComplete = true
+
+    specDone: (spec)->
+        @resultReceived = true
+        spec = extendObject({ logs: @console.captured, errors: [] }, spec )
+        for failure in spec.failedExpectations
+            error = extendObject({trace:[]}, failure )
+            while match = GuardReporter.STACK_MATCHER.exec( failure.stack )
+                error.trace.push({ file: match[1], line: parseInt(match[2]) })
+            delete error.stack
+            spec.errors.push( error )
+        delete spec.failedExpectations
+        @currentSuite.specs.push( spec )
+
+        this.resetConsoleLog()
+        spec
+
+    resetConsoleLog: ->
+        @console.revert()
+        @console = new ConsoleCapture
+
+    eachSuite: (suite)->
+        suites = [].concat( suite.suites )
+        for suite in suite.suites
+            suites = suites.concat( this.eachSuite(suite) )
+        suites
+
+    results: ->
+        stats = {
+            time     : ( Date.now() - @startedAt ) / 1000
+            specs    : 0
+            failed   : 0
+            pending  : 0
+            disabled : 0
+        }
+        for suite in this.eachSuite(@stack[0])
+            stats.specs += suite.specs.length
+            for spec in suite.specs
+                stats[spec.status] += 1 unless undefined == stats[spec.status]
+        {
+            jasmine_version: jasmine?.version
+            stats: stats
+            suites: @stack[0].suites
+        }
+
+if typeof module isnt 'undefined' and module.exports
+    module.exports = GuardReporter
+else
+    window.GuardReporter = GuardReporter

data/lib/guard/jasmine/phantomjs/test/guard-reporter_spec.coffee

@@ -0,0 +1,41 @@
+sinon    = require 'sinon'
+{expect} = require 'chai'
+
+GuardReporter = require '../src/guard-reporter'
+
+describe 'Reporter', ->
+    beforeEach ->
+        @reporter = new GuardReporter
+        @reporter.jasmineStarted()
+
+    it 'captures the console', ->
+        @reporter.suiteStarted({name:'Blank'})
+        console.log("A %s Logging", "Test")
+        console.warn("This is your last warning")
+        @reporter.specDone( { failedExpectations: [] } )
+        expect( @reporter.results() )
+            .to.have.deep.property('.suites[0].specs[0].logs')
+            .and.equal([
+                [ 'log', 'A %s Logging', "Test" ],
+                [ 'warn', 'This is your last warning' ]
+                ])
+
+    it "reports counts", ->
+        @reporter.suiteStarted({name:'Blank'})
+        console.log("A %s Logging", "Test")
+        console.warn("This is your last warning")
+        @reporter.specDone( { status: 'passed', failedExpectations: [] } )
+        @reporter.specDone( { status: 'failed', failedExpectations: [{
+            matcherName:"toEqual",
+            message: "Expected 2 to equal 5"
+        }] })
+        @reporter.specDone( { status: 'passed', failedExpectations: [] } )
+        @reporter.specDone( { status: 'pending', failedExpectations: [] } )
+        results = @reporter.results()
+        expect( results ).to.have.property('stats')
+        expect( results.stats )
+            .to.have.property('specs').and.equal(4)
+        expect( results.stats )
+            .to.have.property('failed').and.equal(1)
+        expect( results.stats )
+            .to.have.property('pending').and.equal(1)

data/lib/guard/jasmine/runner.rb

@@ -11,53 +11,68 @@ module Guard
     # evaluates the JSON response from the PhantomJS Script `guard_jasmine.coffee`,
     # writes the result to the console and triggers optional system notifications.
     #
-    module Runner
-      extend ::Guard::Jasmine::Util
-
-      class << self
-
-        # Name of the coverage threshold options
-        THRESHOLDS = [:statements_threshold, :functions_threshold, :branches_threshold, :lines_threshold]
-
-        # Run the supplied specs.
-        #
-        # @param [Array<String>] paths the spec files or directories
-        # @param [Hash] options the options for the execution
-        # @option options [String] :jasmine_url the url of the Jasmine test runner
-        # @option options [String] :phantomjs_bin the location of the PhantomJS binary
-        # @option options [Integer] :timeout the maximum time in seconds to wait for the spec runner to finish
-        # @option options [String] :rackup_config custom rackup config to use
-        # @option options [Boolean] :notification show notifications
-        # @option options [Boolean] :hide_success hide success message notification
-        # @option options [Integer] :max_error_notify maximum error notifications to show
-        # @option options [Symbol] :specdoc options for the specdoc output, either :always, :never
-        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
-        # @option options [String] :spec_dir the directory with the Jasmine specs
-        # @return [Boolean, Array<String>] the status of the run and the failed files
-        #
-        def run(paths, options = { })
-          return [false, []] if paths.empty?
+    class Runner
+      include ::Guard::Jasmine::Util
+
+      attr_reader :options
+
+      # Name of the coverage threshold options
+      THRESHOLDS = [:statements_threshold, :functions_threshold, :branches_threshold, :lines_threshold]
+
+      # Run the supplied specs.
+      #
+      # @param [Hash] options the options for the execution
+      # @option options [String] :jasmine_url the url of the Jasmine test runner
+      # @option options [String] :phantomjs_bin the location of the PhantomJS binary
+      # @option options [Integer] :timeout the maximum time in seconds to wait for the spec runner to finish
+      # @option options [String] :rackup_config custom rackup config to use
+      # @option options [Boolean] :notification show notifications
+      # @option options [Boolean] :hide_success hide success message notification
+      # @option options [Integer] :max_error_notify maximum error notifications to show
+      # @option options [Symbol] :specdoc options for the specdoc output, either :always, :never
+      # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
+      # @option options [String] :spec_dir the directory with the Jasmine specs
+      # @option options [Hash]   :query_params Parameters to pass along with the request
+      # @option options [Boolean] :debug display raw JSON output from the runner
+      #
+      def initialize(options)
+        @options = options
+      end
 
-          notify_start_message(paths, options)
+      # @param [Array<String>] paths the spec files or directories
+      # @return [Hash<String,Array>] keys for the spec_file, value is array of failure messages.
+      #    Only specs with failures will be returned.  Therefore an empty? return hash indicates success.
+      def run(paths, per_run_options = {})
+        previous_options = @options
+        @options.merge!( per_run_options )
 
-          results = paths.inject([]) do |results, file|
-            results << evaluate_response(run_jasmine_spec(file, options), file, options) if File.exist?(file_and_line_number_parts(file)[0])
+        return {} if paths.empty?
 
-            results
-          end.compact
+        notify_start_message(paths)
 
-          [response_status_for(results), failed_paths_from(results)]
+        run_results = paths.each_with_object({}) do |file, results|
+          if File.exist?(file_and_line_number_parts(file)[0])
+            results[file] = evaluate_response(run_jasmine_spec(file), file)
+          end
+        end
+        # return the errors
+        return run_results.each_with_object({}) do | spec_run, hash |
+          file, r = spec_run
+          errors = collect_spec_errors(r['suites']||[])
+          errors.push( r['error'] ) if r.has_key? 'error'
+          hash[file] = errors unless errors.empty?
         end
+      ensure
+        @options=previous_options
+      end
 
-        private
+    private
 
-        # Shows a notification in the console that the runner starts.
-        #
+      # Shows a notification in the console that the runner starts.
+      #
         # @param [Array<String>] paths the spec files or directories
-        # @param [Hash] options the options for the execution
-        # @option options [String] :spec_dir the directory with the Jasmine specs
         #
-        def notify_start_message(paths, options)
+        def notify_start_message(paths)
           message = if paths == [options[:spec_dir]]
                       'Run all Jasmine suites'
                     else
@@ -67,33 +82,12 @@ module Guard
           Formatter.info(message, reset: true)
         end
 
-        # Returns the failed spec file names.
-        #
-        # @param [Array<Object>] results the spec runner results
-        # @return [Array<String>] the list of failed spec files
-        #
-        def failed_paths_from(results)
-          results.map { |r| !r['passed'] ? r['file'] : nil }.compact
-        end
-
-        # Returns the response status for the given result set.
-        #
-        # @param [Array<Object>] results the spec runner results
-        # @return [Boolean] whether it has passed or not
-        #
-        def response_status_for(results)
-          results.none? { |r| r.has_key?('error') || !r['passed'] }
-        end
-
         # Run the Jasmine spec by executing the PhantomJS script.
         #
         # @param [String] file the path of the spec
-        # @param [Hash] options the options for the execution
-        # @option options [Integer] :timeout the maximum time in seconds to wait for the spec runner to finish
         #
-        def run_jasmine_spec(file, options)
-          suite = jasmine_suite(file, options)
-          Formatter.info("Run Jasmine suite at #{ suite }")
+        def run_jasmine_spec(file)
+          suite = jasmine_suite(file)
 
           arguments = [
             options[:timeout] * 1000,
@@ -105,30 +99,27 @@ module Guard
             options[:junit_consolidate],
             "'#{ options[:junit_save_path] }'"
           ]
-
-          IO.popen("#{ phantomjs_command(options) } \"#{ suite }\" #{ arguments.collect { |i| i.to_s }.join(' ')}", 'r:UTF-8')
+          cmd = "#{ phantomjs_command } \"#{ suite }\" #{ arguments.collect { |i| i.to_s }.join(' ')}"
+          IO.popen(cmd, 'r:UTF-8')
         end
 
         # Get the PhantomJS binary and script to execute.
         #
-        # @param [Hash] options the options for the execution
-        # @option options [String] :phantomjs_bin the location of the PhantomJS binary
         # @return [String] the command
         #
-        def phantomjs_command(options)
+        def phantomjs_command
           options[:phantomjs_bin] + ' ' + phantomjs_script
+          #options[:phantomjs_bin] + ' --remote-debugger-port=9000 ' + phantomjs_script
         end
 
         # Get the Jasmine test runner URL with the appended suite name
         # that acts as the spec filter.
         #
         # @param [String] file the spec file
-        # @param [Hash] options the options for the execution
-        # @option options [String] :jasmine_url the url of the Jasmine test runner
         # @return [String] the Jasmine url
         #
-        def jasmine_suite(file, options)
-          options[:jasmine_url] + query_string_for_suite(file, options)
+        def jasmine_suite(file)
+          options[:jasmine_url] + query_string_for_suite(file)
         end
 
         # Get the PhantomJS script that executes the spec and extracts
@@ -144,22 +135,17 @@ module Guard
         # will be run.
         #
         # @param [String] file the spec file
-        # @param [Hash] options the options for the execution
-        # @option options [String] :spec_dir the directory with the Jasmine specs
         # @return [String] the suite name
         #
-        def query_string_for_suite(file, options)
-          return '' if file == options[:spec_dir]
-
-          query_string = query_string_for_suite_from_line_number(file, options)
-
-          unless query_string
-            query_string = query_string_for_suite_from_first_describe(file, options)
+        def query_string_for_suite(file)
+          params = {}
+          if options[:query_params]
+            params.merge!(options[:query_params])
           end
-
-          query_string = query_string ? "?spec=#{ query_string }" : ''
-
-          URI.encode(query_string)
+          if file != options[:spec_dir]
+            params[:spec] = suite_from_line_number(file) || suite_from_first_describe(file)
+          end
+          params.empty? ? "" : "?"+URI.encode_www_form(params)
         end
 
         # When providing a line number by either the option or by
@@ -167,11 +153,9 @@ module Guard
         # fromt the corresponding line number in the file.
         #
         # @param [String] file the spec file
-        # @param [Hash] options the options for the execution
-        # @option options [Fixnum] :line_number the line number to run
         # @return [String] the suite name
         #
-        def query_string_for_suite_from_line_number(file, options)
+        def suite_from_line_number(file)
           file_name, line_number = file_and_line_number_parts(file)
           line_number ||= options[:line_number]
 
@@ -196,12 +180,11 @@ module Guard
         # found.
         #
         # @param [String] file the spec file
-        # @param [Hash] options the options for the execution
         # @return [String] the suite name
         #
-        def query_string_for_suite_from_first_describe(file, options)
+        def suite_from_first_describe(file)
           File.foreach(file) do |line|
-            if line =~ /describe\s*[("']+(.*?)["')]+/
+            if line =~ /describe\s*[("']+(.*?)["')]+/ #'
               return $1
             end
           end
@@ -241,7 +224,7 @@ module Guard
         # @return [String] the extracted title
         #
         def spec_title(line)
-          line[/['"](.+?)['"]/, 1]
+          line[/['"](.+?)["']/, 1]
         end
 
         # Evaluates the JSON response that the PhantomJS script
@@ -250,33 +233,31 @@ module Guard
         #
         # @param [String] output the JSON output the spec run
         # @param [String] file the file name of the spec
-        # @param [Hash] options the options for the execution
-        # @return [Hash] the suite result
+        # @return [Hash] results of the suite's specs
         #
-        def evaluate_response(output, file, options)
+        def evaluate_response(output, file)
           json = output.read
           json = json.encode('UTF-8') if json.respond_to?(:encode)
-
           begin
             result = MultiJson.decode(json, { max_nesting: false })
             raise 'No response from Jasmine runner' if !result && options[:is_cli]
-
+            pp result if options[:debug]
             if result['error']
               if options[:is_cli]
                 raise 'An error occurred in the Jasmine runner'
               else
-                notify_runtime_error(result, options)
+                notify_runtime_error(result)
               end
             elsif result
               result['file'] = file
-              notify_spec_result(result, options)
+              notify_spec_result(result)
             end
 
             if result && result['coverage'] && options[:coverage]
-              notify_coverage_result(result['coverage'], file, options)
+              notify_coverage_result(result['coverage'], file)
             end
 
-            result
+            return result
 
           rescue MultiJson::DecodeError => e
             if e.data == ''
@@ -287,10 +268,11 @@ module Guard
               end
             else
               if options[:is_cli]
-                raise 'Cannot decode JSON from PhantomJS runner'
+                raise "Cannot decode JSON from PhantomJS runner, message received was:\n#{json}"
               else
                 Formatter.error("Cannot decode JSON from PhantomJS runner: #{ e.message }")
                 Formatter.error("JSON response: #{ e.data }")
+                Formatter.error("message received was:\n#{json}")
               end
             end
           ensure
@@ -302,12 +284,11 @@ module Guard
         # prohibits the execution of the Jasmine spec.
         #
         # @param [Hash] result the suite result
-        # @param [Hash] options the options for the execution
-        # @option options [Boolean] :notification show notifications
         #
-        def notify_runtime_error(result, options)
+        def notify_runtime_error(result)
           message = "An error occurred: #{ result['error'] }"
-          Formatter.error(message)
+          Formatter.error(message )
+          Formatter.error( result['trace'] ) if result['trace']
           Formatter.notify(message, title: 'Jasmine error', image: :failed, priority: 2) if options[:notification]
         end
 
@@ -315,62 +296,59 @@ module Guard
         # and some stats.
         #
         # @param [Hash] result the suite result
-        # @param [Hash] options the options for the execution
-        # @option options [Boolean] :notification show notifications
-        # @option options [Boolean] :hide_success hide success message notification
         #
-        def notify_spec_result(result, options)
-          specs           = result['stats']['specs']
-          failures        = result['stats']['failures']
-          time            = result['stats']['time']
-          specs_plural    = specs == 1 ? '' : 's'
-          failures_plural = failures == 1 ? '' : 's'
-
-          Formatter.info("\nFinished in #{ time } seconds")
-
-          message      = "#{ specs } spec#{ specs_plural }, #{ failures } failure#{ failures_plural }"
+        def notify_spec_result(result)
+          specs         = result['stats']['specs'] - result['stats']['disabled']
+          failed        = result['stats']['failed']
+          time          = sprintf( '%0.2f', result['stats']['time'] )
+          specs_plural  = specs == 1 ? '' : 's'
+          failed_plural = failed == 1 ? '' : 's'
+          Formatter.info("Finished in #{ time } seconds")
+          pending = result['stats']['pending'].to_i > 0 ? " #{result['stats']['pending']} pending," : ""
+          message      = "#{ specs } spec#{ specs_plural },#{pending} #{ failed } failure#{ failed_plural }"
           full_message = "#{ message }\nin #{ time } seconds"
-          passed       = failures == 0
+          passed       = failed == 0
+
+          report_specdoc(result, passed) if specdoc_shown?(passed)
 
           if passed
-            report_specdoc(result, passed, options)
             Formatter.success(message)
             Formatter.notify(full_message, title: 'Jasmine suite passed') if options[:notification] && !options[:hide_success]
           else
-            report_specdoc(result, passed, options)
+            errors = collect_spec_errors(result['suites'])
+            error_message = errors[0..options[:max_error_notify]].join("\n")
+
             Formatter.error(message)
-            notify_errors(result, options)
-            Formatter.notify(full_message, title: 'Jasmine suite failed', image: :failed, priority: 2) if options[:notification]
+            if options[:notification]
+              Formatter.notify( "#{error_message}\n#{full_message}",
+                title: 'Jasmine suite failed', image: :failed, priority: 2)
+            end
           end
 
-          Formatter.info("Done.\n")
         end
 
-        # Notification about the coverage of a spec run, success or failure,
+        # Notification about the coverage of a spec run, success or failed,
         # and some stats.
         #
         # @param [Hash] coverage the coverage hash from the JSON
         # @param [String] file the file name of the spec
-        # @param [Hash] options the options for the execution
-        # @option options [Boolean] :notification show notifications
-        # @option options [Boolean] :hide_success hide success message notification
         #
-        def notify_coverage_result(coverage, file, options)
+        def notify_coverage_result(coverage, file)
           if coverage_bin
             FileUtils.mkdir_p(coverage_root) unless File.exist?(coverage_root)
 
-            update_coverage(coverage, file, options)
+            update_coverage(coverage, file)
 
             if options[:coverage_summary]
               generate_summary_report
             else
-              generate_text_report(file, options)
+              generate_text_report(file)
             end
 
-            check_coverage(options)
+            check_coverage
 
             if options[:coverage_html]
-              generate_html_report(options)
+              generate_html_report
             end
           else
             Formatter.error('Skipping coverage report: unable to locate istanbul in your PATH')
@@ -381,9 +359,8 @@ module Guard
         # last coverage run.
         #
         # @param [String] file the file name of the spec
-        # @param [Hash] options the options for the execution
         #
-        def generate_text_report(file, options)
+        def generate_text_report(file)
           Formatter.info 'Spec coverage details:'
 
           if file == options[:spec_dir]
@@ -405,11 +382,9 @@ module Guard
         # Uses the Istanbul text reported to output the result of the
         # last coverage run.
         #
-        # @param [Hash] options the options for the coverage
-        #
-        def check_coverage(options)
-          if any_coverage_threshold?(options)
-            coverage = `#{coverage_bin} check-coverage #{ istanbul_coverage_options(options) } #{ coverage_file } 2>&1`
+        def check_coverage
+          if any_coverage_threshold?
+            coverage = `#{coverage_bin} check-coverage #{ istanbul_coverage_options } #{ coverage_file } 2>&1`
             coverage = coverage.split("\n").grep(/ERROR/).join.sub('ERROR:', '')
             failed   = $? && $?.exitstatus != 0
 
@@ -426,10 +401,8 @@ module Guard
         # Uses the Istanbul text reported to output the result of the
         # last coverage run.
         #
-        # @param [Hash] options for the HTML report
-        #
-        def generate_html_report(options)
-          report_directory = coverage_report_directory(options)
+        def generate_html_report
+          report_directory = coverage_report_directory
           `#{coverage_bin} report --dir #{ report_directory } --root #{ coverage_root } html #{ coverage_file }`
           Formatter.info "Updated HTML report available at: #{ report_directory }/index.html"
         end
@@ -453,12 +426,10 @@ module Guard
         #
         # @param [Hash] result the suite result
         # @param [Boolean] passed status
-        # @param [Hash] options the options
-        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
         #
-        def report_specdoc(result, passed, options)
+        def report_specdoc(result, passed)
           result['suites'].each do |suite|
-            report_specdoc_suite(suite, passed, options)
+            report_specdoc_suite(suite, passed)
           end
         end
 
@@ -466,128 +437,78 @@ module Guard
         #
         # @param [Hash] suite the suite
         # @param [Boolean] passed status
-        # @param [Hash] options the options
-        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
-        # @option options [Symbol] :focus options for focus on failures in the specdoc
         # @param [Number] level the indention level
         #
-        def report_specdoc_suite(suite, passed, options, level = 0)
-          # Print the suite description when the specdoc is shown or there are logs to display
-          if specdoc_shown?(passed, options) || console_logs_shown?(suite, passed, options) || error_logs_shown?(suite, passed, options)
-            Formatter.suite_name((' ' * level) + suite['description']) if passed || options[:focus] && contains_failed_spec?(suite)
-          end
+        def report_specdoc_suite(suite, run_passed, level = 0)
+
+         # Print the suite description when the specdoc is shown or there are logs to display
+          Formatter.suite_name((' ' * level) + suite['description'])
 
           suite['specs'].each do |spec|
-            if spec['passed']
-              if passed || !options[:focus] || console_for_spec?(spec, options) || errors_for_spec?(spec, options)
-                Formatter.success(indent("  ✔ #{ spec['description'] }", level)) if description_shown?(passed, spec, options)
-                report_specdoc_errors(spec, options, level)
-                report_specdoc_logs(spec, options, level)
-              end
+            # Specs are shown if they failed, or if they passed and the "focus" option is falsey
+            # If specs are going to be shown, then pending are also shown
+            # If the focus option is set, then only failing tests are shown
+            next unless :always==options[:specdoc] || spec['status'] == 'failed' || ( !run_passed && !options[:focus] )
+            if spec['status'] == 'passed'
+              Formatter.success(indent("  ✔ #{ spec['description'] }", level))
+            elsif spec['status'] == 'failed'
+              Formatter.spec_failed(indent("  ✘ #{ spec['description'] }", level))
             else
-              Formatter.spec_failed(indent("  ✘ #{ spec['description'] }", level)) if description_shown?(passed, spec, options)
-              spec['messages'].each do |message|
-                Formatter.spec_failed(indent("    ➤ #{ format_message(message, false) }", level)) if specdoc_shown?(passed, options)
-              end
-              report_specdoc_errors(spec, options, level)
-              report_specdoc_logs(spec, options, level)
+              Formatter.spec_pending(indent("  ○ #{ spec['description'] }", level))
             end
+            report_specdoc_errors(spec, level)
+            report_specdoc_logs(spec, level)
           end
 
-          suite['suites'].each { |s| report_specdoc_suite(s, passed, options, level + 2) } if suite['suites']
+          suite['suites'].each { |s| report_specdoc_suite(s, run_passed, level + 2) } if suite['suites']
         end
 
         # Is the specdoc shown for this suite?
         #
         # @param [Boolean] passed the spec status
-        # @param [Hash] options the options
         #
-        def specdoc_shown?(passed, options = { })
+        def specdoc_shown?(passed)
           options[:specdoc] == :always || (options[:specdoc] == :failure && !passed)
         end
 
-        # Are console logs shown for this suite?
-        #
-        # @param [Hash] suite the suite
-        # @param [Boolean] passed the spec status
-        # @param [Hash] options the options
-        #
-        def console_logs_shown?(suite, passed, options = { })
-          # Are console messages displayed?
-          console_enabled          = options[:console] == :always || (options[:console] == :failure && !passed)
-
-          # Are there any logs to display at all for this suite?
-          logs_for_current_options = suite['specs'].select do |spec|
-            spec['logs'] && (options[:console] == :always || (options[:console] == :failure && !spec['passed']))
-          end
-
-          any_logs_present = !logs_for_current_options.empty?
-
-          console_enabled && any_logs_present
-        end
 
         # Are console logs shown for this spec?
         #
         # @param [Hash] spec the spec
-        # @param [Hash] options the options
         #
-        def console_for_spec?(spec, options = { })
-          spec['logs'] && ((spec['passed'] && options[:console] == :always) ||
-            (!spec['passed'] && options[:console] != :never))
+        def console_for_spec?(spec)
+          spec['logs'] && (( spec['status'] == 'passed' && options[:console] == :always) ||
+            (spec['status'] == 'failed' && options[:console] != :never) )
         end
 
-        # Are error logs shown for this suite?
-        #
-        # @param [Hash] suite the suite
-        # @param [Boolean] passed the spec status
-        # @param [Hash] options the options
-        #
-        def error_logs_shown?(suite, passed, options = { })
-          # Are error messages displayed?
-          errors_enabled             = options[:errors] == :always || (options[:errors] == :failure && !passed)
-
-          # Are there any errors to display at all for this suite?
-          errors_for_current_options = suite['specs'].select do |spec|
-            spec['errors'] && (options[:errors] == :always || (options[:errors] == :failure && !spec['passed']))
-          end
-
-          any_errors_present= !errors_for_current_options.empty?
-
-          errors_enabled && any_errors_present
-        end
 
         # Are errors shown for this spec?
         #
         # @param [Hash] spec the spec
-        # @param [Hash] options the options
-        def errors_for_spec?(spec, options = { })
-          spec['errors'] && ((spec['passed'] && options[:errors] == :always) ||
-            (!spec['passed'] && options[:errors] != :never))
+        def errors_for_spec?(spec)
+          spec['errors'] && ((spec['status']=='passed' && options[:errors] == :always) ||
+            (spec['status']=='failed' && options[:errors] != :never))
         end
 
         # Is the description shown for this spec?
         #
         # @param [Boolean] passed the spec status
         # @param [Hash] spec the spec
-        # @param [Hash] options the options
         #
-        def description_shown?(passed, spec, options = { })
-          specdoc_shown?(passed, options) || console_for_spec?(spec, options) || errors_for_spec?(spec, options)
+        def description_shown?(passed, spec)
+          specdoc_shown?(passed) || console_for_spec?(spec) || errors_for_spec?(spec)
         end
 
         # Shows the logs for a given spec.
         #
         # @param [Hash] spec the spec result
-        # @param [Hash] options the options
-        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
         # @param [Number] level the indention level
         #
-        def report_specdoc_logs(spec, options, level)
-          if spec['logs'] && (options[:console] == :always || (options[:console] == :failure && !spec['passed']))
-            spec['logs'].each do |log|
-              log.split("\n").each_with_index do |message, index|
-                Formatter.info(indent("    #{ index == 0 ? '•' : ' ' } #{ message }", level))
-              end
+        def report_specdoc_logs(spec, level)
+          if console_for_spec?(spec)
+            spec['logs'].each do |log_level, message|
+              log_level = log_level == 'log' ? '' : "#{log_level.upcase}: "
+              Formatter.info(indent("    • #{log_level}#{ message }", level))
             end
           end
         end
@@ -595,19 +516,16 @@ module Guard
         # Shows the errors for a given spec.
         #
         # @param [Hash] spec the spec result
-        # @param [Hash] options the options
-        # @option options [Symbol] :errors options for the errors output, either :always, :never or :failure
         # @param [Number] level the indention level
         #
-        def report_specdoc_errors(spec, options, level)
-          if spec['errors'] && (options[:errors] == :always || (options[:errors] == :failure && !spec['passed']))
+        def report_specdoc_errors(spec, level)
+          if spec['errors'] && (options[:errors] == :always || (options[:errors] == :failure && spec['status']=='failed'))
             spec['errors'].each do |error|
+              Formatter.spec_failed(indent("    ➤ #{ format_error(error,true)  }", level))
               if error['trace']
                 error['trace'].each do |trace|
-                  Formatter.spec_failed(indent("    ➜ Exception: #{ error['msg']  } in #{ trace['file'] } on line #{ trace['line'] }", level))
+                  Formatter.spec_failed(indent("    ➜ #{ trace['file'] } on line #{ trace['line'] }", level+2))
                 end
-              else
-                Formatter.spec_failed(indent("    ➜ Exception: #{ error['msg']  }", level))
               end
             end
           end
@@ -622,24 +540,6 @@ module Guard
           (' ' * level) + message
         end
 
-        # Show system notifications about the occurred errors.
-        #
-        # @param [Hash] result the suite result
-        # @param [Hash] options the options
-        # @option options [Integer] :max_error_notify maximum error notifications to show
-        # @option options [Boolean] :notification show notifications
-        #
-        def notify_errors(result, options)
-          collect_specs(result['suites']).each_with_index do |spec, index|
-            if !spec['passed'] && options[:max_error_notify] > index
-              msg = spec['messages'].map { |message| format_message(message, true) }.join(', ')
-              Formatter.notify("#{ spec['description'] }: #{ msg }",
-                               title:    'Jasmine spec failed',
-                               image:    :failed,
-                               priority: 2) if options[:notification]
-            end
-          end
-        end
 
         # Tests if the given suite has a failing spec underneath.
         #
@@ -647,7 +547,19 @@ module Guard
         # @return [Boolean] the search result
         #
         def contains_failed_spec?(suite)
-          collect_specs([suite]).any? { |spec| !spec['passed'] }
+          collect_specs([suite]).any? { |spec| spec['status'] == 'failed' }
+        end
+
+
+        # Get all failed specs from the suites and its nested suites.
+        #
+        # @param suites [Array<Hash>] the suites results
+        # @return [Array<Hash>] all failed
+        #
+        def collect_spec_errors(suites)
+          collect_specs(suites).map { |spec|
+            (spec['errors']||[]).map { |error| format_error(error,false) }
+          }.flatten
         end
 
         # Get all specs from the suites and its nested suites.
@@ -656,10 +568,9 @@ module Guard
         # @return [Array<Hash>] all specs
         #
         def collect_specs(suites)
-          suites.inject([]) do |specs, suite|
-            specs = (specs | suite['specs']) if suite['specs']
-            specs = (specs | collect_specs(suite['suites'])) if suite['suites']
-            specs
+          suites.each_with_object([]) do |suite, specs|
+            specs.concat( suite['specs'] )
+            specs.concat( collect_specs(suite['suites']) ) if suite['suites']
           end
         end
 
@@ -669,9 +580,11 @@ module Guard
         # @param [Boolean] short show a short version of the message
         # @return [String] the cleaned error message
         #
-        def format_message(message, short)
-          if message =~ /(.*?) in http.+?assets\/(.*)\?body=\d+\s\((line\s\d+)/
-            short ? $1 : "#{ $1 } in #{ $2 } on #{ $3 }"
+        def format_error(error, short)
+          message = error['message'].gsub(%r{ in http.*\(line \d+\)$},'')
+          if !short && error['trace'] && error['trace'].length > 0
+            location = error['trace'][0]
+            "#{message} in #{location['file']}:#{location['line']}"
           else
             message
           end
@@ -682,9 +595,8 @@ module Guard
         #
         # @param [Hash] coverage the last run coverage data
         # @param [String] file the file name of the spec
-        # @param [Hash] options the options for the execution
         #
-        def update_coverage(coverage, file, options)
+        def update_coverage(coverage, file)
           if file == options[:spec_dir]
             File.write(coverage_file, MultiJson.encode(coverage, { max_nesting: false }))
           else
@@ -707,16 +619,15 @@ module Guard
         #
         # @return [Boolean] true if any coverage threshold is set
         #
-        def any_coverage_threshold?(options)
+        def any_coverage_threshold?
           THRESHOLDS.any? { |threshold| options[threshold] != 0 }
         end
 
         # Converts the options to Istanbul recognized options
         #
-        # @param [Hash] options the options for the coverage
         # @return [String] the command line options
         #
-        def istanbul_coverage_options(options)
+        def istanbul_coverage_options
           THRESHOLDS.inject([]) do |coverage, name|
             threshold = options[name]
             coverage << (threshold != 0 ? "--#{ name.to_s.sub('_threshold', '') } #{ threshold }" : '')
@@ -750,13 +661,12 @@ module Guard
 
         # Creates and returns the coverage report directory.
         #
-        # @param [Hash] options for the coverage report directory
         # @return [String] the coverage report directory
         #
-        def coverage_report_directory(options)
+        def coverage_report_directory
           File.expand_path(options[:coverage_html_dir])
         end
-      end
     end
   end
 end
+